Add ru version (#1865)

* Add Russian docs site baseline

* Add Russian localized codebase

* Polish Russian code wording

* Update ru code translation.

* Update code translation and chapter covers.

* Fix pythontutor extraction.

* Add README and landing page.

* placeholder of profiles

* Use figures of English version

* Remove chapter paperbook

ru/codes/csharp/.editorconfig

@@ -0,0 +1,88 @@
+# CSharp formatting rules
+[*.cs]
+csharp_new_line_before_open_brace = none
+csharp_new_line_before_else = false
+csharp_new_line_before_catch = false
+csharp_new_line_before_finally = false
+csharp_indent_labels = one_less_than_current
+csharp_using_directive_placement = outside_namespace:silent
+csharp_prefer_simple_using_statement = true:suggestion
+csharp_prefer_braces = true:silent
+csharp_style_namespace_declarations = block_scoped:silent
+csharp_style_prefer_method_group_conversion = true:silent
+csharp_style_prefer_top_level_statements = true:silent
+csharp_style_prefer_primary_constructors = true:suggestion
+csharp_style_expression_bodied_methods = false:silent
+csharp_style_expression_bodied_constructors = false:silent
+csharp_style_expression_bodied_operators = false:silent
+csharp_style_expression_bodied_properties = true:silent
+csharp_style_expression_bodied_indexers = true:silent
+csharp_style_expression_bodied_accessors = true:silent
+csharp_style_expression_bodied_lambdas = true:silent
+
+# CS8981: The type name only contains lower-cased ascii characters. Such names may become reserved for the language.
+dotnet_diagnostic.CS8981.severity = silent
+
+# IDE1006: Naming Styles
+dotnet_diagnostic.IDE1006.severity = silent
+
+# CA1822: Mark members as static
+dotnet_diagnostic.CA1822.severity = silent
+
+[*.{cs,vb}]
+#### Naming styles ####
+
+# Naming rules
+
+dotnet_naming_rule.interface_should_be_begins_with_i.severity = suggestion
+dotnet_naming_rule.interface_should_be_begins_with_i.symbols = interface
+dotnet_naming_rule.interface_should_be_begins_with_i.style = begins_with_i
+
+dotnet_naming_rule.types_should_be_pascal_case.severity = suggestion
+dotnet_naming_rule.types_should_be_pascal_case.symbols = types
+dotnet_naming_rule.types_should_be_pascal_case.style = pascal_case
+
+dotnet_naming_rule.non_field_members_should_be_pascal_case.severity = suggestion
+dotnet_naming_rule.non_field_members_should_be_pascal_case.symbols = non_field_members
+dotnet_naming_rule.non_field_members_should_be_pascal_case.style = pascal_case
+
+# Symbol specifications
+
+dotnet_naming_symbols.interface.applicable_kinds = interface
+dotnet_naming_symbols.interface.applicable_accessibilities = public, internal, private, protected, protected_internal, private_protected
+dotnet_naming_symbols.interface.required_modifiers = 
+
+dotnet_naming_symbols.types.applicable_kinds = class, struct, interface, enum
+dotnet_naming_symbols.types.applicable_accessibilities = public, internal, private, protected, protected_internal, private_protected
+dotnet_naming_symbols.types.required_modifiers = 
+
+dotnet_naming_symbols.non_field_members.applicable_kinds = property, event, method
+dotnet_naming_symbols.non_field_members.applicable_accessibilities = public, internal, private, protected, protected_internal, private_protected
+dotnet_naming_symbols.non_field_members.required_modifiers = 
+
+# Naming styles
+
+dotnet_naming_style.begins_with_i.required_prefix = I
+dotnet_naming_style.begins_with_i.required_suffix = 
+dotnet_naming_style.begins_with_i.word_separator = 
+dotnet_naming_style.begins_with_i.capitalization = pascal_case
+
+dotnet_naming_style.pascal_case.required_prefix = 
+dotnet_naming_style.pascal_case.required_suffix = 
+dotnet_naming_style.pascal_case.word_separator = 
+dotnet_naming_style.pascal_case.capitalization = pascal_case
+
+dotnet_naming_style.pascal_case.required_prefix = 
+dotnet_naming_style.pascal_case.required_suffix = 
+dotnet_naming_style.pascal_case.word_separator = 
+dotnet_naming_style.pascal_case.capitalization = pascal_case
+dotnet_style_operator_placement_when_wrapping = beginning_of_line
+tab_width = 4
+indent_size = 4
+end_of_line = crlf
+
+# IDE0040: Add accessibility modifiers
+dotnet_diagnostic.IDE0040.severity = silent
+
+# IDE0044: Add readonly modifier
+dotnet_diagnostic.IDE0044.severity = silent

ru/codes/csharp/.gitignore

@@ -0,0 +1,5 @@
+.idea/
+.vs/
+obj/
+.Debug
+bin/

ru/codes/csharp/.vscode/launch.json

@@ -0,0 +1,26 @@
+{
+  "version": "0.2.0",
+  "configurations": [
+    {
+      // Use IntelliSense to find out which attributes exist for C# debugging
+      // Use hover for the description of the existing attributes
+      // For further information visit https://github.com/OmniSharp/omnisharp-vscode/blob/master/debugger-launchjson.md
+      "name": ".NET Core Launch (console)",
+      "type": "coreclr",
+      "request": "launch",
+      "preLaunchTask": "build",
+      // If you have changed target frameworks, make sure to update the program path.
+      "program": "${workspaceFolder}/bin/Debug/net6.0/hello-algo.dll",
+      "args": [],
+      "cwd": "${workspaceFolder}",
+      // For more information about the 'console' field, see https://aka.ms/VSCode-CS-LaunchJson-Console
+      "console": "internalConsole",
+      "stopAtEntry": false
+    },
+    {
+      "name": ".NET Core Attach",
+      "type": "coreclr",
+      "request": "attach"
+    }
+  ]
+}

ru/codes/csharp/.vscode/tasks.json

@@ -0,0 +1,41 @@
+{
+  "version": "2.0.0",
+  "tasks": [
+    {
+      "label": "build",
+      "command": "dotnet",
+      "type": "process",
+      "args": [
+        "build",
+        "${workspaceFolder}/hello-algo.csproj",
+        "/property:GenerateFullPaths=true",
+        "/consoleloggerparameters:NoSummary"
+      ],
+      "problemMatcher": "$msCompile"
+    },
+    {
+      "label": "publish",
+      "command": "dotnet",
+      "type": "process",
+      "args": [
+        "publish",
+        "${workspaceFolder}/hello-algo.csproj",
+        "/property:GenerateFullPaths=true",
+        "/consoleloggerparameters:NoSummary"
+      ],
+      "problemMatcher": "$msCompile"
+    },
+    {
+      "label": "watch",
+      "command": "dotnet",
+      "type": "process",
+      "args": [
+        "watch",
+        "run",
+        "--project",
+        "${workspaceFolder}/hello-algo.csproj"
+      ],
+      "problemMatcher": "$msCompile"
+    }
+  ]
+}

ru/codes/csharp/GlobalUsing.cs

@@ -0,0 +1,3 @@
+global using NUnit.Framework;
+global using hello_algo.utils;
+global using System.Text;

ru/codes/csharp/chapter_array_and_linkedlist/array.cs

@@ -0,0 +1,107 @@
+// File: array.cs
+// Created Time: 2022-12-14
+// Author: mingXta (1195669834@qq.com)
+
+namespace hello_algo.chapter_array_and_linkedlist;
+
+public class array {
+    /* Случайный доступ к элементу */
+    int RandomAccess(int[] nums) {
+        Random random = new();
+        // Случайным образом выбрать число из интервала [0, nums.Length)
+        int randomIndex = random.Next(nums.Length);
+        // Получить и вернуть случайный элемент
+        int randomNum = nums[randomIndex];
+        return randomNum;
+    }
+
+    /* Увеличить длину массива */
+    int[] Extend(int[] nums, int enlarge) {
+        // Инициализировать массив увеличенной длины
+        int[] res = new int[nums.Length + enlarge];
+        // Скопировать все элементы исходного массива в новый массив
+        for (int i = 0; i < nums.Length; i++) {
+            res[i] = nums[i];
+        }
+        // Вернуть новый массив после расширения
+        return res;
+    }
+
+    /* Вставить элемент num по индексу index в массив */
+    void Insert(int[] nums, int num, int index) {
+        // Сдвинуть элемент с индексом index и все последующие элементы на одну позицию назад
+        for (int i = nums.Length - 1; i > index; i--) {
+            nums[i] = nums[i - 1];
+        }
+        // Присвоить num элементу по индексу index
+        nums[index] = num;
+    }
+
+    /* Удалить элемент по индексу index */
+    void Remove(int[] nums, int index) {
+        // Сдвинуть все элементы после индекса index на одну позицию вперед
+        for (int i = index; i < nums.Length - 1; i++) {
+            nums[i] = nums[i + 1];
+        }
+    }
+
+    /* Обход массива */
+    void Traverse(int[] nums) {
+        int count = 0;
+        // Обход массива по индексам
+        for (int i = 0; i < nums.Length; i++) {
+            count += nums[i];
+        }
+        // Непосредственно обходить элементы массива
+        foreach (int num in nums) {
+            count += num;
+        }
+    }
+
+    /* Найти заданный элемент в массиве */
+    int Find(int[] nums, int target) {
+        for (int i = 0; i < nums.Length; i++) {
+            if (nums[i] == target)
+                return i;
+        }
+        return -1;
+    }
+
+    /* Вспомогательная функция: преобразовать массив в строку */
+    string ToString(int[] nums) {
+        return string.Join(",", nums);
+    }
+
+
+    [Test]
+    public void Test() {
+        // Инициализация массива
+        int[] arr = new int[5];
+        Console.WriteLine("Массив arr = " + ToString(arr));
+        int[] nums = [1, 3, 2, 5, 4];
+        Console.WriteLine("Массив nums = " + ToString(nums));
+
+        // Случайный доступ
+        int randomNum = RandomAccess(nums);
+        Console.WriteLine("Случайный элемент из nums = " + randomNum);
+
+        // Расширение длины
+        nums = Extend(nums, 3);
+        Console.WriteLine("После увеличения длины массива до 8 nums = " + ToString(nums));
+
+        // Вставка элемента
+        Insert(nums, 6, 3);
+        Console.WriteLine("После вставки числа 6 по индексу 3 nums = " + ToString(nums));
+
+        // Удаление элемента
+        Remove(nums, 2);
+        Console.WriteLine("После удаления элемента по индексу 2 nums = " + ToString(nums));
+
+        // Обход массива
+        Traverse(nums);
+
+        // Поиск элемента
+        int index = Find(nums, 3);
+        Console.WriteLine("Поиск элемента 3 в nums: индекс = " + index);
+    }
+}

ru/codes/csharp/chapter_array_and_linkedlist/linked_list.cs

@@ -0,0 +1,80 @@
+// File: linked_list.cs
+// Created Time: 2022-12-16
+// Author: mingXta (1195669834@qq.com)
+
+namespace hello_algo.chapter_array_and_linkedlist;
+
+public class linked_list {
+    /* Вставить узел P после узла n0 в связном списке */
+    void Insert(ListNode n0, ListNode P) {
+        ListNode? n1 = n0.next;
+        P.next = n1;
+        n0.next = P;
+    }
+
+    /* Удалить первый узел после узла n0 в связном списке */
+    void Remove(ListNode n0) {
+        if (n0.next == null)
+            return;
+        // n0 -> P -> n1
+        ListNode P = n0.next;
+        ListNode? n1 = P.next;
+        n0.next = n1;
+    }
+
+    /* Доступ к узлу связного списка по индексу index */
+    ListNode? Access(ListNode? head, int index) {
+        for (int i = 0; i < index; i++) {
+            if (head == null)
+                return null;
+            head = head.next;
+        }
+        return head;
+    }
+
+    /* Найти в связном списке первый узел со значением target */
+    int Find(ListNode? head, int target) {
+        int index = 0;
+        while (head != null) {
+            if (head.val == target)
+                return index;
+            head = head.next;
+            index++;
+        }
+        return -1;
+    }
+
+
+    [Test]
+    public void Test() {
+        // Инициализация связного списка
+        // Инициализация всех узлов
+        ListNode n0 = new(1);
+        ListNode n1 = new(3);
+        ListNode n2 = new(2);
+        ListNode n3 = new(5);
+        ListNode n4 = new(4);
+        // Построить ссылки между узлами
+        n0.next = n1;
+        n1.next = n2;
+        n2.next = n3;
+        n3.next = n4;
+        Console.WriteLine($"Исходный связный список: {n0}");
+
+        // Вставка узла
+        Insert(n0, new ListNode(0));
+        Console.WriteLine($"Связный список после вставки узла: {n0}");
+
+        // Удаление узла
+        Remove(n0);
+        Console.WriteLine($"Связный список после удаления узла: {n0}");
+
+        // Доступ к узлу
+        ListNode? node = Access(n0, 3);
+        Console.WriteLine($"Значение узла по индексу 3 в связном списке = {node?.val}");
+
+        // Поиск узла
+        int index = Find(n0, 2);
+        Console.WriteLine($"Индекс узла со значением 2 в связном списке = {index}");
+    }
+}

ru/codes/csharp/chapter_array_and_linkedlist/list.cs

@@ -0,0 +1,66 @@
+/**
+ * File: list.cs
+ * Created Time: 2022-12-23
+ * Author: haptear (haptear@hotmail.com)
+ */
+
+namespace hello_algo.chapter_array_and_linkedlist;
+
+public class list {
+    [Test]
+    public void Test() {
+
+        /* Инициализация списка */
+        int[] numbers = [1, 3, 2, 5, 4];
+        List<int> nums = [.. numbers];
+        Console.WriteLine("Список nums = " + string.Join(",", nums));
+
+        /* Доступ к элементу */
+        int num = nums[1];
+        Console.WriteLine("Элемент по индексу 1: num = " + num);
+
+        /* Обновление элемента */
+        nums[1] = 0;
+        Console.WriteLine("После обновления элемента по индексу 1 до 0 nums = " + string.Join(",", nums));
+
+        /* Очистить список */
+        nums.Clear();
+        Console.WriteLine("После очистки списка nums = " + string.Join(",", nums));
+
+        /* Добавление элемента в конец */
+        nums.Add(1);
+        nums.Add(3);
+        nums.Add(2);
+        nums.Add(5);
+        nums.Add(4);
+        Console.WriteLine("После добавления элементов nums = " + string.Join(",", nums));
+
+        /* Вставка элемента в середину */
+        nums.Insert(3, 6);
+        Console.WriteLine("После вставки числа 6 по индексу 3 nums = " + string.Join(",", nums));
+
+        /* Удаление элемента */
+        nums.RemoveAt(3);
+        Console.WriteLine("После удаления элемента по индексу 3 nums = " + string.Join(",", nums));
+
+        /* Обходить список по индексам */
+        int count = 0;
+        for (int i = 0; i < nums.Count; i++) {
+            count += nums[i];
+        }
+        /* Непосредственно обходить элементы списка */
+        count = 0;
+        foreach (int x in nums) {
+            count += x;
+        }
+
+        /* Объединить два списка */
+        List<int> nums1 = [6, 8, 7, 10, 9];
+        nums.AddRange(nums1);
+        Console.WriteLine("После конкатенации списка nums1 к nums nums = " + string.Join(",", nums));
+
+        /* Отсортировать список */
+        nums.Sort(); // После сортировки элементы списка располагаются по возрастанию
+        Console.WriteLine("После сортировки списка nums = " + string.Join(",", nums));
+    }
+}

ru/codes/csharp/chapter_array_and_linkedlist/my_list.cs

@@ -0,0 +1,144 @@
+/**
+ * File: my_list.cs
+ * Created Time: 2022-12-23
+ * Author: haptear (haptear@hotmail.com)
+ */
+
+namespace hello_algo.chapter_array_and_linkedlist;
+
+/* Класс списка */
+class MyList {
+    private int[] arr;           // Массив (для хранения элементов списка)
+    private int arrCapacity = 10;    // Вместимость списка
+    private int arrSize = 0;         // Длина списка (текущее число элементов)
+    private readonly int extendRatio = 2;  // Коэффициент увеличения списка при каждом расширении
+
+    /* Конструктор */
+    public MyList() {
+        arr = new int[arrCapacity];
+    }
+
+    /* Получить длину списка (текущее число элементов) */
+    public int Size() {
+        return arrSize;
+    }
+
+    /* Получить вместимость списка */
+    public int Capacity() {
+        return arrCapacity;
+    }
+
+    /* Доступ к элементу */
+    public int Get(int index) {
+        // Если индекс выходит за границы, выбрасывается исключение; далее аналогично
+        if (index < 0 || index >= arrSize)
+            throw new IndexOutOfRangeException("индекс выходит за границы");
+        return arr[index];
+    }
+
+    /* Обновление элемента */
+    public void Set(int index, int num) {
+        if (index < 0 || index >= arrSize)
+            throw new IndexOutOfRangeException("индекс выходит за границы");
+        arr[index] = num;
+    }
+
+    /* Добавление элемента в конец */
+    public void Add(int num) {
+        // При превышении вместимости по числу элементов запускается расширение
+        if (arrSize == arrCapacity)
+            ExtendCapacity();
+        arr[arrSize] = num;
+        // Обновить число элементов
+        arrSize++;
+    }
+
+    /* Вставка элемента в середину */
+    public void Insert(int index, int num) {
+        if (index < 0 || index >= arrSize)
+            throw new IndexOutOfRangeException("индекс выходит за границы");
+        // При превышении вместимости по числу элементов запускается расширение
+        if (arrSize == arrCapacity)
+            ExtendCapacity();
+        // Сдвинуть элемент с индексом index и все следующие элементы на одну позицию назад
+        for (int j = arrSize - 1; j >= index; j--) {
+            arr[j + 1] = arr[j];
+        }
+        arr[index] = num;
+        // Обновить число элементов
+        arrSize++;
+    }
+
+    /* Удаление элемента */
+    public int Remove(int index) {
+        if (index < 0 || index >= arrSize)
+            throw new IndexOutOfRangeException("индекс выходит за границы");
+        int num = arr[index];
+        // Сдвинуть все элементы после индекса index на одну позицию вперед
+        for (int j = index; j < arrSize - 1; j++) {
+            arr[j] = arr[j + 1];
+        }
+        // Обновить число элементов
+        arrSize--;
+        // Вернуть удаленный элемент
+        return num;
+    }
+
+    /* Расширение списка */
+    public void ExtendCapacity() {
+        // Создать новый массив длиной arrCapacity * extendRatio и скопировать в него исходный массив
+        Array.Resize(ref arr, arrCapacity * extendRatio);
+        // Обновить вместимость списка
+        arrCapacity = arr.Length;
+    }
+
+    /* Преобразовать список в массив */
+    public int[] ToArray() {
+        // Преобразовывать только элементы списка в пределах фактической длины
+        int[] arr = new int[arrSize];
+        for (int i = 0; i < arrSize; i++) {
+            arr[i] = Get(i);
+        }
+        return arr;
+    }
+}
+
+public class my_list {
+    [Test]
+    public void Test() {
+        /* Инициализация списка */
+        MyList nums = new();
+        /* Добавление элемента в конец */
+        nums.Add(1);
+        nums.Add(3);
+        nums.Add(2);
+        nums.Add(5);
+        nums.Add(4);
+        Console.WriteLine("Список nums = " + string.Join(",", nums.ToArray()) +
+                           ", вместимость = " + nums.Capacity() + " , длина = " + nums.Size());
+
+        /* Вставка элемента в середину */
+        nums.Insert(3, 6);
+        Console.WriteLine("После вставки числа 6 по индексу 3 nums = " + string.Join(",", nums.ToArray()));
+
+        /* Удаление элемента */
+        nums.Remove(3);
+        Console.WriteLine("После удаления элемента по индексу 3 nums = " + string.Join(",", nums.ToArray()));
+
+        /* Доступ к элементу */
+        int num = nums.Get(1);
+        Console.WriteLine("Элемент по индексу 1: num = " + num);
+
+        /* Обновление элемента */
+        nums.Set(1, 0);
+        Console.WriteLine("После обновления элемента по индексу 1 до 0 nums = " + string.Join(",", nums.ToArray()));
+
+        /* Проверка механизма расширения */
+        for (int i = 0; i < 10; i++) {
+            // При i = 5 длина списка превысит его вместимость, и в этот момент сработает механизм расширения
+            nums.Add(i);
+        }
+        Console.WriteLine("Список nums после увеличения вместимости = " + string.Join(",", nums.ToArray()) +
+                           ", вместимость = " + nums.Capacity() + " , длина = " + nums.Size());
+    }
+}

ru/codes/csharp/chapter_backtracking/n_queens.cs

@@ -0,0 +1,76 @@
+/**
+ * File: n_queens.cs
+ * Created Time: 2023-05-04
+ * Author: hpstory (hpstory1024@163.com)
+ */
+
+namespace hello_algo.chapter_backtracking;
+
+public class n_queens {
+    /* Алгоритм бэктрекинга: n ферзей */
+    void Backtrack(int row, int n, List<List<string>> state, List<List<List<string>>> res,
+            bool[] cols, bool[] diags1, bool[] diags2) {
+        // Когда все строки уже обработаны, записать решение
+        if (row == n) {
+            List<List<string>> copyState = [];
+            foreach (List<string> sRow in state) {
+                copyState.Add(new List<string>(sRow));
+            }
+            res.Add(copyState);
+            return;
+        }
+        // Обойти все столбцы
+        for (int col = 0; col < n; col++) {
+            // Вычислить главную и побочную диагонали, соответствующие этой клетке
+            int diag1 = row - col + n - 1;
+            int diag2 = row + col;
+            // Отсечение: в столбце, главной диагонали и побочной диагонали этой клетки не должно быть ферзей
+            if (!cols[col] && !diags1[diag1] && !diags2[diag2]) {
+                // Попытка: поставить ферзя в эту клетку
+                state[row][col] = "Q";
+                cols[col] = diags1[diag1] = diags2[diag2] = true;
+                // Перейти к размещению следующей строки
+                Backtrack(row + 1, n, state, res, cols, diags1, diags2);
+                // Откат: восстановить эту клетку как пустую
+                state[row][col] = "#";
+                cols[col] = diags1[diag1] = diags2[diag2] = false;
+            }
+        }
+    }
+
+    /* Решить задачу о n ферзях */
+    List<List<List<string>>> NQueens(int n) {
+        // Инициализировать доску размера n*n, где 'Q' обозначает ферзя, а '#' — пустую клетку
+        List<List<string>> state = [];
+        for (int i = 0; i < n; i++) {
+            List<string> row = [];
+            for (int j = 0; j < n; j++) {
+                row.Add("#");
+            }
+            state.Add(row);
+        }
+        bool[] cols = new bool[n]; // Отмечать, есть ли ферзь в столбце
+        bool[] diags1 = new bool[2 * n - 1]; // Отмечать наличие ферзя на главной диагонали
+        bool[] diags2 = new bool[2 * n - 1]; // Отмечать наличие ферзя на побочной диагонали
+        List<List<List<string>>> res = [];
+
+        Backtrack(0, n, state, res, cols, diags1, diags2);
+
+        return res;
+    }
+
+    [Test]
+    public void Test() {
+        int n = 4;
+        List<List<List<string>>> res = NQueens(n);
+
+        Console.WriteLine("Размер входной доски = " + n);
+        Console.WriteLine("Количество способов расстановки ферзей: " + res.Count);
+        foreach (List<List<string>> state in res) {
+            Console.WriteLine("--------------------");
+            foreach (List<string> row in state) {
+                PrintUtil.PrintList(row);
+            }
+        }
+    }
+}

ru/codes/csharp/chapter_backtracking/permutations_i.cs

@@ -0,0 +1,53 @@
+/**
+ * File: permutations_i.cs
+ * Created Time: 2023-04-24
+ * Author: hpstory (hpstory1024@163.com)
+ */
+
+namespace hello_algo.chapter_backtracking;
+
+public class permutations_i {
+    /* Алгоритм бэктрекинга: все перестановки I */
+    void Backtrack(List<int> state, int[] choices, bool[] selected, List<List<int>> res) {
+        // Когда длина состояния равна числу элементов, записать решение
+        if (state.Count == choices.Length) {
+            res.Add(new List<int>(state));
+            return;
+        }
+        // Перебор всех вариантов выбора
+        for (int i = 0; i < choices.Length; i++) {
+            int choice = choices[i];
+            // Отсечение: нельзя выбирать один и тот же элемент повторно
+            if (!selected[i]) {
+                // Попытка: сделать выбор и обновить состояние
+                selected[i] = true;
+                state.Add(choice);
+                // Перейти к следующему выбору
+                Backtrack(state, choices, selected, res);
+                // Откат: отменить выбор и восстановить предыдущее состояние
+                selected[i] = false;
+                state.RemoveAt(state.Count - 1);
+            }
+        }
+    }
+
+    /* Все перестановки I */
+    List<List<int>> PermutationsI(int[] nums) {
+        List<List<int>> res = [];
+        Backtrack([], nums, new bool[nums.Length], res);
+        return res;
+    }
+
+    [Test]
+    public void Test() {
+        int[] nums = [1, 2, 3];
+
+        List<List<int>> res = PermutationsI(nums);
+
+        Console.WriteLine("Входной массив nums = " + string.Join(", ", nums));
+        Console.WriteLine("Все перестановки res = ");
+        foreach (List<int> permutation in res) {
+            PrintUtil.PrintList(permutation);
+        }
+    }
+}

ru/codes/csharp/chapter_backtracking/permutations_ii.cs

@@ -0,0 +1,55 @@
+/**
+ * File: permutations_ii.cs
+ * Created Time: 2023-04-24
+ * Author: hpstory (hpstory1024@163.com)
+ */
+
+namespace hello_algo.chapter_backtracking;
+
+public class permutations_ii {
+    /* Алгоритм бэктрекинга: все перестановки II */
+    void Backtrack(List<int> state, int[] choices, bool[] selected, List<List<int>> res) {
+        // Когда длина состояния равна числу элементов, записать решение
+        if (state.Count == choices.Length) {
+            res.Add(new List<int>(state));
+            return;
+        }
+        // Перебор всех вариантов выбора
+        HashSet<int> duplicated = [];
+        for (int i = 0; i < choices.Length; i++) {
+            int choice = choices[i];
+            // Отсечение: нельзя выбирать один и тот же элемент повторно и нельзя повторно выбирать равные элементы
+            if (!selected[i] && !duplicated.Contains(choice)) {
+                // Попытка: сделать выбор и обновить состояние
+                duplicated.Add(choice); // Записать значения уже выбранных элементов
+                selected[i] = true;
+                state.Add(choice);
+                // Перейти к следующему выбору
+                Backtrack(state, choices, selected, res);
+                // Откат: отменить выбор и восстановить предыдущее состояние
+                selected[i] = false;
+                state.RemoveAt(state.Count - 1);
+            }
+        }
+    }
+
+    /* Все перестановки II */
+    List<List<int>> PermutationsII(int[] nums) {
+        List<List<int>> res = [];
+        Backtrack([], nums, new bool[nums.Length], res);
+        return res;
+    }
+
+    [Test]
+    public void Test() {
+        int[] nums = [1, 2, 2];
+
+        List<List<int>> res = PermutationsII(nums);
+
+        Console.WriteLine("Входной массив nums = " + string.Join(", ", nums));
+        Console.WriteLine("Все перестановки res = ");
+        foreach (List<int> permutation in res) {
+            PrintUtil.PrintList(permutation);
+        }
+    }
+}

ru/codes/csharp/chapter_backtracking/preorder_traversal_i_compact.cs

@@ -0,0 +1,37 @@
+/**
+ * File: preorder_traversal_i_compact.cs
+ * Created Time: 2023-04-17
+ * Author: hpstory (hpstory1024@163.com)
+ */
+
+namespace hello_algo.chapter_backtracking;
+
+public class preorder_traversal_i_compact {
+    List<TreeNode> res = [];
+
+    /* Предварительный обход: пример 1 */
+    void PreOrder(TreeNode? root) {
+        if (root == null) {
+            return;
+        }
+        if (root.val == 7) {
+            // Записать решение
+            res.Add(root);
+        }
+        PreOrder(root.left);
+        PreOrder(root.right);
+    }
+
+    [Test]
+    public void Test() {
+        TreeNode? root = TreeNode.ListToTree([1, 7, 3, 4, 5, 6, 7]);
+        Console.WriteLine("\nИнициализация двоичного дерева");
+        PrintUtil.PrintTree(root);
+
+        // Предварительный обход
+        PreOrder(root);
+
+        Console.WriteLine("\nВсе узлы со значением 7");
+        PrintUtil.PrintList(res.Select(p => p.val).ToList());
+    }
+}

ru/codes/csharp/chapter_backtracking/preorder_traversal_ii_compact.cs

@@ -0,0 +1,44 @@
+/**
+ * File: preorder_traversal_ii_compact.cs
+ * Created Time: 2023-04-17
+ * Author: hpstory (hpstory1024@163.com)
+ */
+
+namespace hello_algo.chapter_backtracking;
+
+public class preorder_traversal_ii_compact {
+    List<TreeNode> path = [];
+    List<List<TreeNode>> res = [];
+
+    /* Предварительный обход: пример 2 */
+    void PreOrder(TreeNode? root) {
+        if (root == null) {
+            return;
+        }
+        // Попытка
+        path.Add(root);
+        if (root.val == 7) {
+            // Записать решение
+            res.Add(new List<TreeNode>(path));
+        }
+        PreOrder(root.left);
+        PreOrder(root.right);
+        // Откат
+        path.RemoveAt(path.Count - 1);
+    }
+
+    [Test]
+    public void Test() {
+        TreeNode? root = TreeNode.ListToTree([1, 7, 3, 4, 5, 6, 7]);
+        Console.WriteLine("\nИнициализация двоичного дерева");
+        PrintUtil.PrintTree(root);
+
+        // Предварительный обход
+        PreOrder(root);
+
+        Console.WriteLine("\nВсе пути от корня к узлу 7");
+        foreach (List<TreeNode> path in res) {
+            PrintUtil.PrintList(path.Select(p => p.val).ToList());
+        }
+    }
+}

ru/codes/csharp/chapter_backtracking/preorder_traversal_iii_compact.cs

@@ -0,0 +1,45 @@
+/**
+ * File: preorder_traversal_iii_compact.cs
+ * Created Time: 2023-04-17
+ * Author: hpstory (hpstory1024@163.com)
+ */
+
+namespace hello_algo.chapter_backtracking;
+
+public class preorder_traversal_iii_compact {
+    List<TreeNode> path = [];
+    List<List<TreeNode>> res = [];
+
+    /* Предварительный обход: пример 3 */
+    void PreOrder(TreeNode? root) {
+        // Отсечение
+        if (root == null || root.val == 3) {
+            return;
+        }
+        // Попытка
+        path.Add(root);
+        if (root.val == 7) {
+            // Записать решение
+            res.Add(new List<TreeNode>(path));
+        }
+        PreOrder(root.left);
+        PreOrder(root.right);
+        // Откат
+        path.RemoveAt(path.Count - 1);
+    }
+
+    [Test]
+    public void Test() {
+        TreeNode? root = TreeNode.ListToTree([1, 7, 3, 4, 5, 6, 7]);
+        Console.WriteLine("\nИнициализация двоичного дерева");
+        PrintUtil.PrintTree(root);
+
+        // Предварительный обход
+        PreOrder(root);
+
+        Console.WriteLine("\nВсе пути от корня к узлу 7, не содержащие узлов со значением 3");
+        foreach (List<TreeNode> path in res) {
+            PrintUtil.PrintList(path.Select(p => p.val).ToList());
+        }
+    }
+}

ru/codes/csharp/chapter_backtracking/preorder_traversal_iii_template.cs

@@ -0,0 +1,72 @@
+/**
+ * File: preorder_traversal_iii_template.cs
+ * Created Time: 2023-04-17
+ * Author: hpstory (hpstory1024@163.com)
+ */
+
+namespace hello_algo.chapter_backtracking;
+
+public class preorder_traversal_iii_template {
+    /* Проверить, является ли текущее состояние решением */
+    bool IsSolution(List<TreeNode> state) {
+        return state.Count != 0 && state[^1].val == 7;
+    }
+
+    /* Записать решение */
+    void RecordSolution(List<TreeNode> state, List<List<TreeNode>> res) {
+        res.Add(new List<TreeNode>(state));
+    }
+
+    /* Проверить, допустим ли этот выбор в текущем состоянии */
+    bool IsValid(List<TreeNode> state, TreeNode choice) {
+        return choice != null && choice.val != 3;
+    }
+
+    /* Обновить состояние */
+    void MakeChoice(List<TreeNode> state, TreeNode choice) {
+        state.Add(choice);
+    }
+
+    /* Восстановить состояние */
+    void UndoChoice(List<TreeNode> state, TreeNode choice) {
+        state.RemoveAt(state.Count - 1);
+    }
+
+    /* Алгоритм бэктрекинга: пример 3 */
+    void Backtrack(List<TreeNode> state, List<TreeNode> choices, List<List<TreeNode>> res) {
+        // Проверить, является ли текущее состояние решением
+        if (IsSolution(state)) {
+            // Записать решение
+            RecordSolution(state, res);
+        }
+        // Перебор всех вариантов выбора
+        foreach (TreeNode choice in choices) {
+            // Отсечение: проверить допустимость выбора
+            if (IsValid(state, choice)) {
+                // Попытка: сделать выбор и обновить состояние
+                MakeChoice(state, choice);
+                // Перейти к следующему выбору
+                Backtrack(state, [choice.left!, choice.right!], res);
+                // Откат: отменить выбор и восстановить предыдущее состояние
+                UndoChoice(state, choice);
+            }
+        }
+    }
+
+    [Test]
+    public void Test() {
+        TreeNode? root = TreeNode.ListToTree([1, 7, 3, 4, 5, 6, 7]);
+        Console.WriteLine("\nИнициализация двоичного дерева");
+        PrintUtil.PrintTree(root);
+
+        // Алгоритм бэктрекинга
+        List<List<TreeNode>> res = [];
+        List<TreeNode> choices = [root!];
+        Backtrack([], choices, res);
+
+        Console.WriteLine("\nВсе пути от корня к узлу 7, в которых путь не содержит узлов со значением 3");
+        foreach (List<TreeNode> path in res) {
+            PrintUtil.PrintList(path.Select(p => p.val).ToList());
+        }
+    }
+}

ru/codes/csharp/chapter_backtracking/subset_sum_i.cs

@@ -0,0 +1,55 @@
+/**
+* File: subset_sum_i.cs
+* Created Time: 2023-06-25
+* Author: hpstory (hpstory1024@163.com)
+*/
+
+namespace hello_algo.chapter_backtracking;
+
+public class subset_sum_i {
+    /* Алгоритм бэктрекинга: сумма подмножеств I */
+    void Backtrack(List<int> state, int target, int[] choices, int start, List<List<int>> res) {
+        // Если сумма подмножества равна target, записать решение
+        if (target == 0) {
+            res.Add(new List<int>(state));
+            return;
+        }
+        // Обойти все варианты выбора
+        // Отсечение 2: начинать обход с start, чтобы избежать генерации повторяющихся подмножеств
+        for (int i = start; i < choices.Length; i++) {
+            // Отсечение 1: если сумма подмножества превышает target, немедленно завершить цикл
+            // Это связано с тем, что массив уже отсортирован, следующие элементы больше, и сумма подмножества точно превысит target
+            if (target - choices[i] < 0) {
+                break;
+            }
+            // Попытка: сделать выбор и обновить target и start
+            state.Add(choices[i]);
+            // Перейти к следующему выбору
+            Backtrack(state, target - choices[i], choices, i, res);
+            // Откат: отменить выбор и восстановить предыдущее состояние
+            state.RemoveAt(state.Count - 1);
+        }
+    }
+
+    /* Решить задачу суммы подмножеств I */
+    List<List<int>> SubsetSumI(int[] nums, int target) {
+        List<int> state = []; // Состояние (подмножество)
+        Array.Sort(nums); // Отсортировать nums
+        int start = 0; // Стартовая вершина обхода
+        List<List<int>> res = []; // Список результатов (список подмножеств)
+        Backtrack(state, target, nums, start, res);
+        return res;
+    }
+
+    [Test]
+    public void Test() {
+        int[] nums = [3, 4, 5];
+        int target = 9;
+        List<List<int>> res = SubsetSumI(nums, target);
+        Console.WriteLine("Входной массив nums = " + string.Join(", ", nums) + ", target = " + target);
+        Console.WriteLine("Все подмножества с суммой " + target + ": res = ");
+        foreach (var subset in res) {
+            PrintUtil.PrintList(subset);
+        }
+    }
+}

ru/codes/csharp/chapter_backtracking/subset_sum_i_naive.cs

@@ -0,0 +1,53 @@
+/**
+* File: subset_sum_i_naive.cs
+* Created Time: 2023-06-25
+* Author: hpstory (hpstory1024@163.com)
+*/
+
+namespace hello_algo.chapter_backtracking;
+
+public class subset_sum_i_naive {
+    /* Алгоритм бэктрекинга: сумма подмножеств I */
+    void Backtrack(List<int> state, int target, int total, int[] choices, List<List<int>> res) {
+        // Если сумма подмножества равна target, записать решение
+        if (total == target) {
+            res.Add(new List<int>(state));
+            return;
+        }
+        // Перебор всех вариантов выбора
+        for (int i = 0; i < choices.Length; i++) {
+            // Отсечение: если сумма подмножества превышает target, пропустить этот выбор
+            if (total + choices[i] > target) {
+                continue;
+            }
+            // Попытка: сделать выбор и обновить элемент и total
+            state.Add(choices[i]);
+            // Перейти к следующему выбору
+            Backtrack(state, target, total + choices[i], choices, res);
+            // Откат: отменить выбор и восстановить предыдущее состояние
+            state.RemoveAt(state.Count - 1);
+        }
+    }
+
+    /* Решить задачу суммы подмножеств I (с повторяющимися подмножествами) */
+    List<List<int>> SubsetSumINaive(int[] nums, int target) {
+        List<int> state = []; // Состояние (подмножество)
+        int total = 0; // Сумма подмножеств
+        List<List<int>> res = []; // Список результатов (список подмножеств)
+        Backtrack(state, target, total, nums, res);
+        return res;
+    }
+
+    [Test]
+    public void Test() {
+        int[] nums = [3, 4, 5];
+        int target = 9;
+        List<List<int>> res = SubsetSumINaive(nums, target);
+        Console.WriteLine("Входной массив nums = " + string.Join(", ", nums) + ", target = " + target);
+        Console.WriteLine("Все подмножества с суммой " + target + ": res = ");
+        foreach (var subset in res) {
+            PrintUtil.PrintList(subset);
+        }
+        Console.WriteLine("Обратите внимание: результат этого метода содержит повторяющиеся множества");
+    }
+}

ru/codes/csharp/chapter_backtracking/subset_sum_ii.cs

@@ -0,0 +1,60 @@
+/**
+* File: subset_sum_ii.cs
+* Created Time: 2023-06-25
+* Author: hpstory (hpstory1024@163.com)
+*/
+
+namespace hello_algo.chapter_backtracking;
+
+public class subset_sum_ii {
+    /* Алгоритм бэктрекинга: сумма подмножеств II */
+    void Backtrack(List<int> state, int target, int[] choices, int start, List<List<int>> res) {
+        // Если сумма подмножества равна target, записать решение
+        if (target == 0) {
+            res.Add(new List<int>(state));
+            return;
+        }
+        // Обойти все варианты выбора
+        // Отсечение 2: начинать обход с start, чтобы избежать генерации повторяющихся подмножеств
+        // Отсечение 3: начинать обход с start, чтобы избежать повторного выбора одного и того же элемента
+        for (int i = start; i < choices.Length; i++) {
+            // Отсечение 1: если сумма подмножества превышает target, немедленно завершить цикл
+            // Это связано с тем, что массив уже отсортирован, следующие элементы больше, и сумма подмножества точно превысит target
+            if (target - choices[i] < 0) {
+                break;
+            }
+            // Отсечение 4: если этот элемент равен элементу слева, значит ветвь поиска повторяется, ее нужно сразу пропустить
+            if (i > start && choices[i] == choices[i - 1]) {
+                continue;
+            }
+            // Попытка: сделать выбор и обновить target и start
+            state.Add(choices[i]);
+            // Перейти к следующему выбору
+            Backtrack(state, target - choices[i], choices, i + 1, res);
+            // Откат: отменить выбор и восстановить предыдущее состояние
+            state.RemoveAt(state.Count - 1);
+        }
+    }
+
+    /* Решить задачу суммы подмножеств II */
+    List<List<int>> SubsetSumII(int[] nums, int target) {
+        List<int> state = []; // Состояние (подмножество)
+        Array.Sort(nums); // Отсортировать nums
+        int start = 0; // Стартовая вершина обхода
+        List<List<int>> res = []; // Список результатов (список подмножеств)
+        Backtrack(state, target, nums, start, res);
+        return res;
+    }
+
+    [Test]
+    public void Test() {
+        int[] nums = [4, 4, 5];
+        int target = 9;
+        List<List<int>> res = SubsetSumII(nums, target);
+        Console.WriteLine("Входной массив nums = " + string.Join(", ", nums) + ", target = " + target);
+        Console.WriteLine("Все подмножества с суммой " + target + ": res = ");
+        foreach (var subset in res) {
+            PrintUtil.PrintList(subset);
+        }
+    }
+}

ru/codes/csharp/chapter_computational_complexity/iteration.cs

@@ -0,0 +1,77 @@
+/**
+* File: iteration.cs
+* Created Time: 2023-08-28
+* Author: hpstory (hpstory1024@163.com)
+*/
+
+namespace hello_algo.chapter_computational_complexity;
+
+public class iteration {
+    /* Цикл for */
+    int ForLoop(int n) {
+        int res = 0;
+        // Циклическое суммирование 1, 2, ..., n-1, n
+        for (int i = 1; i <= n; i++) {
+            res += i;
+        }
+        return res;
+    }
+
+    /* Цикл while */
+    int WhileLoop(int n) {
+        int res = 0;
+        int i = 1; // Инициализация условной переменной
+        // Циклическое суммирование 1, 2, ..., n-1, n
+        while (i <= n) {
+            res += i;
+            i += 1; // Обновить условную переменную
+        }
+        return res;
+    }
+
+    /* Цикл while (двойное обновление) */
+    int WhileLoopII(int n) {
+        int res = 0;
+        int i = 1; // Инициализация условной переменной
+        // Циклическое суммирование 1, 4, 10, ...
+        while (i <= n) {
+            res += i;
+            // Обновить условную переменную
+            i += 1; 
+            i *= 2;
+        }
+        return res;
+    }
+
+    /* Двойной цикл for */
+    string NestedForLoop(int n) {
+        StringBuilder res = new();
+        // Цикл по i = 1, 2, ..., n-1, n
+        for (int i = 1; i <= n; i++) {
+            // Цикл по j = 1, 2, ..., n-1, n
+            for (int j = 1; j <= n; j++) {
+                res.Append($"({i}, {j}), ");
+            }
+        }
+        return res.ToString();
+    }
+
+    /* Driver Code */
+    [Test]
+    public void Test() {
+        int n = 5;
+        int res;
+
+        res = ForLoop(n);
+        Console.WriteLine("\nРезультат суммирования в цикле for res = " + res);
+
+        res = WhileLoop(n);
+        Console.WriteLine("\nРезультат суммирования в цикле while res = " + res);
+
+        res = WhileLoopII(n);
+        Console.WriteLine("\nРезультат суммирования в цикле while (двойное обновление) res = " + res);
+
+        string resStr = NestedForLoop(n);
+        Console.WriteLine("\nРезультат обхода в двойном цикле for " + resStr);
+    }
+}

ru/codes/csharp/chapter_computational_complexity/recursion.cs

@@ -0,0 +1,78 @@
+/**
+* File: recursion.cs
+* Created Time: 2023-08-28
+* Author: hpstory (hpstory1024@163.com)
+*/
+
+namespace hello_algo.chapter_computational_complexity;
+
+public class recursion {
+    /* Рекурсия */
+    int Recur(int n) {
+        // Условие завершения
+        if (n == 1)
+            return 1;
+        // Рекурсия: рекурсивный вызов
+        int res = Recur(n - 1);
+        // Возврат: вернуть результат
+        return n + res;
+    }
+
+    /* Имитация рекурсии итерацией */
+    int ForLoopRecur(int n) {
+        // Использовать явный стек для имитации системного стека вызовов
+        Stack<int> stack = new();
+        int res = 0;
+        // Рекурсия: рекурсивный вызов
+        for (int i = n; i > 0; i--) {
+            // Имитировать «рекурсию» с помощью операции помещения в стек
+            stack.Push(i);
+        }
+        // Возврат: вернуть результат
+        while (stack.Count > 0) {
+            // Имитировать «возврат» с помощью операции извлечения из стека
+            res += stack.Pop();
+        }
+        // res = 1+2+3+...+n
+        return res;
+    }
+
+    /* Хвостовая рекурсия */
+    int TailRecur(int n, int res) {
+        // Условие завершения
+        if (n == 0)
+            return res;
+        // Хвостовой рекурсивный вызов
+        return TailRecur(n - 1, res + n);
+    }
+
+    /* Последовательность Фибоначчи: рекурсия */
+    int Fib(int n) {
+        // Условие завершения: f(1) = 0, f(2) = 1
+        if (n == 1 || n == 2)
+            return n - 1;
+        // Рекурсивный вызов f(n) = f(n-1) + f(n-2)
+        int res = Fib(n - 1) + Fib(n - 2);
+        // Вернуть результат f(n)
+        return res;
+    }
+
+    /* Driver Code */
+    [Test]
+    public void Test() {
+        int n = 5;
+        int res;
+
+        res = Recur(n);
+        Console.WriteLine("\nРезультат суммирования в рекурсивной функции res = " + res);
+
+        res = ForLoopRecur(n);
+        Console.WriteLine("\nРезультат суммирования при имитации рекурсии итерацией res = " + res);
+
+        res = TailRecur(n, 0);
+        Console.WriteLine("\nРезультат суммирования в хвостовой рекурсии res = " + res);
+
+        res = Fib(n);
+        Console.WriteLine("\nЧлен последовательности Фибоначчи с номером " + n + " = " + res);
+    }
+}

ru/codes/csharp/chapter_computational_complexity/space_complexity.cs

@@ -0,0 +1,104 @@
+/**
+ * File: space_complexity.cs
+ * Created Time: 2022-12-23
+ * Author: haptear (haptear@hotmail.com)
+ */
+
+namespace hello_algo.chapter_computational_complexity;
+
+public class space_complexity {
+    /* Функция */
+    int Function() {
+        // Выполнить некоторые операции
+        return 0;
+    }
+
+    /* Постоянная сложность */
+    void Constant(int n) {
+        // Константы, переменные и объекты занимают O(1) памяти
+        int a = 0;
+        int b = 0;
+        int[] nums = new int[10000];
+        ListNode node = new(0);
+        // Переменные в цикле занимают O(1) памяти
+        for (int i = 0; i < n; i++) {
+            int c = 0;
+        }
+        // Функции в цикле занимают O(1) памяти
+        for (int i = 0; i < n; i++) {
+            Function();
+        }
+    }
+
+    /* Линейная сложность */
+    void Linear(int n) {
+        // Массив длины n занимает O(n) памяти
+        int[] nums = new int[n];
+        // Список длины n занимает O(n) памяти
+        List<ListNode> nodes = [];
+        for (int i = 0; i < n; i++) {
+            nodes.Add(new ListNode(i));
+        }
+        // Хеш-таблица длины n занимает O(n) памяти
+        Dictionary<int, string> map = [];
+        for (int i = 0; i < n; i++) {
+            map.Add(i, i.ToString());
+        }
+    }
+
+    /* Линейная сложность (рекурсивная реализация) */
+    void LinearRecur(int n) {
+        Console.WriteLine("Рекурсия n = " + n);
+        if (n == 1) return;
+        LinearRecur(n - 1);
+    }
+
+    /* Квадратичная сложность */
+    void Quadratic(int n) {
+        // Матрица занимает O(n^2) памяти
+        int[,] numMatrix = new int[n, n];
+        // Двумерный список занимает O(n^2) памяти
+        List<List<int>> numList = [];
+        for (int i = 0; i < n; i++) {
+            List<int> tmp = [];
+            for (int j = 0; j < n; j++) {
+                tmp.Add(0);
+            }
+            numList.Add(tmp);
+        }
+    }
+
+    /* Квадратичная сложность (рекурсивная реализация) */
+    int QuadraticRecur(int n) {
+        if (n <= 0) return 0;
+        int[] nums = new int[n];
+        Console.WriteLine("В рекурсии n = " + n + ", длина nums = " + nums.Length);
+        return QuadraticRecur(n - 1);
+    }
+
+    /* Экспоненциальная сложность (построение полного двоичного дерева) */
+    TreeNode? BuildTree(int n) {
+        if (n == 0) return null;
+        TreeNode root = new(0) {
+            left = BuildTree(n - 1),
+            right = BuildTree(n - 1)
+        };
+        return root;
+    }
+
+    [Test]
+    public void Test() {
+        int n = 5;
+        // Постоянная сложность
+        Constant(n);
+        // Линейная сложность
+        Linear(n);
+        LinearRecur(n);
+        // Квадратичная сложность
+        Quadratic(n);
+        QuadraticRecur(n);
+        // Экспоненциальная сложность
+        TreeNode? root = BuildTree(n);
+        PrintUtil.PrintTree(root);
+    }
+}

ru/codes/csharp/chapter_computational_complexity/time_complexity.cs

@@ -0,0 +1,195 @@
+/**
+ * File: time_complexity.cs
+ * Created Time: 2022-12-23
+ * Author: haptear (haptear@hotmail.com)
+ */
+
+namespace hello_algo.chapter_computational_complexity;
+
+public class time_complexity {
+    void Algorithm(int n) {
+        int a = 1;  // +0 (прием 1)
+        a += n;  // +0 (прием 1)
+        // +n (прием 2)
+        for (int i = 0; i < 5 * n + 1; i++) {
+            Console.WriteLine(0);
+        }
+        // +n*n (прием 3)
+        for (int i = 0; i < 2 * n; i++) {
+            for (int j = 0; j < n + 1; j++) {
+                Console.WriteLine(0);
+            }
+        }
+    }
+
+    // Временная сложность алгоритма A: константная
+    void AlgorithmA(int n) {
+        Console.WriteLine(0);
+    }
+
+    // Временная сложность алгоритма B: линейная
+    void AlgorithmB(int n) {
+        for (int i = 0; i < n; i++) {
+            Console.WriteLine(0);
+        }
+    }
+
+    // Временная сложность алгоритма C: константная
+    void AlgorithmC(int n) {
+        for (int i = 0; i < 1000000; i++) {
+            Console.WriteLine(0);
+        }
+    }
+
+    /* Постоянная сложность */
+    int Constant(int n) {
+        int count = 0;
+        int size = 100000;
+        for (int i = 0; i < size; i++)
+            count++;
+        return count;
+    }
+
+    /* Линейная сложность */
+    int Linear(int n) {
+        int count = 0;
+        for (int i = 0; i < n; i++)
+            count++;
+        return count;
+    }
+
+    /* Линейная сложность (обход массива) */
+    int ArrayTraversal(int[] nums) {
+        int count = 0;
+        // Число итераций пропорционально длине массива
+        foreach (int num in nums) {
+            count++;
+        }
+        return count;
+    }
+
+    /* Квадратичная сложность */
+    int Quadratic(int n) {
+        int count = 0;
+        // Число итераций квадратично зависит от размера данных n
+        for (int i = 0; i < n; i++) {
+            for (int j = 0; j < n; j++) {
+                count++;
+            }
+        }
+        return count;
+    }
+
+    /* Квадратичная сложность (пузырьковая сортировка) */
+    int BubbleSort(int[] nums) {
+        int count = 0;  // Счетчик
+        // Внешний цикл: неотсортированный диапазон [0, i]
+        for (int i = nums.Length - 1; i > 0; i--) {
+            // Внутренний цикл: переместить максимальный элемент неотсортированного диапазона [0, i] в его правый конец
+            for (int j = 0; j < i; j++) {
+                if (nums[j] > nums[j + 1]) {
+                    // Поменять местами nums[j] и nums[j + 1]
+                    (nums[j + 1], nums[j]) = (nums[j], nums[j + 1]);
+                    count += 3;  // Обмен элементов включает 3 элементарные операции
+                }
+            }
+        }
+        return count;
+    }
+
+    /* Экспоненциальная сложность (итеративная реализация) */
+    int Exponential(int n) {
+        int count = 0, bas = 1;
+        // На каждом шаге клетка делится надвое, образуя последовательность 1, 2, 4, 8, ..., 2^(n-1)
+        for (int i = 0; i < n; i++) {
+            for (int j = 0; j < bas; j++) {
+                count++;
+            }
+            bas *= 2;
+        }
+        // count = 1 + 2 + 4 + 8 + .. + 2^(n-1) = 2^n - 1
+        return count;
+    }
+
+    /* Экспоненциальная сложность (рекурсивная реализация) */
+    int ExpRecur(int n) {
+        if (n == 1) return 1;
+        return ExpRecur(n - 1) + ExpRecur(n - 1) + 1;
+    }
+
+    /* Логарифмическая сложность (итеративная реализация) */
+    int Logarithmic(int n) {
+        int count = 0;
+        while (n > 1) {
+            n /= 2;
+            count++;
+        }
+        return count;
+    }
+
+    /* Логарифмическая сложность (рекурсивная реализация) */
+    int LogRecur(int n) {
+        if (n <= 1) return 0;
+        return LogRecur(n / 2) + 1;
+    }
+
+    /* Линейно-логарифмическая сложность */
+    int LinearLogRecur(int n) {
+        if (n <= 1) return 1;
+        int count = LinearLogRecur(n / 2) + LinearLogRecur(n / 2);
+        for (int i = 0; i < n; i++) {
+            count++;
+        }
+        return count;
+    }
+
+    /* Факториальная сложность (рекурсивная реализация) */
+    int FactorialRecur(int n) {
+        if (n == 0) return 1;
+        int count = 0;
+        // Из одного получается n
+        for (int i = 0; i < n; i++) {
+            count += FactorialRecur(n - 1);
+        }
+        return count;
+    }
+
+    [Test]
+    public void Test() {
+        // Можно изменить n и запустить программу, чтобы увидеть, как меняется число операций при разных сложностях
+        int n = 8;
+        Console.WriteLine("Размер входных данных n = " + n);
+
+        int count = Constant(n);
+        Console.WriteLine("Число операций константной сложности = " + count);
+
+        count = Linear(n);
+        Console.WriteLine("Число операций линейной сложности = " + count);
+        count = ArrayTraversal(new int[n]);
+        Console.WriteLine("Число операций линейной сложности (обход массива) = " + count);
+
+        count = Quadratic(n);
+        Console.WriteLine("Число операций квадратичной сложности = " + count);
+        int[] nums = new int[n];
+        for (int i = 0; i < n; i++)
+            nums[i] = n - i;  // [n,n-1,...,2,1]
+        count = BubbleSort(nums);
+        Console.WriteLine("Число операций квадратичной сложности (пузырьковая сортировка) = " + count);
+
+        count = Exponential(n);
+        Console.WriteLine("Число операций экспоненциальной сложности (итеративная реализация) = " + count);
+        count = ExpRecur(n);
+        Console.WriteLine("Число операций экспоненциальной сложности (рекурсивная реализация) = " + count);
+
+        count = Logarithmic(n);
+        Console.WriteLine("Число операций логарифмической сложности (итеративная реализация) = " + count);
+        count = LogRecur(n);
+        Console.WriteLine("Число операций логарифмической сложности (рекурсивная реализация) = " + count);
+
+        count = LinearLogRecur(n);
+        Console.WriteLine("Число операций линейно-логарифмической сложности (рекурсивная реализация) = " + count);
+
+        count = FactorialRecur(n);
+        Console.WriteLine("Число операций факториальной сложности (рекурсивная реализация) = " + count);
+    }
+}

ru/codes/csharp/chapter_computational_complexity/worst_best_time_complexity.cs

@@ -0,0 +1,49 @@
+/**
+ * File: worst_best_time_complexity.cs
+ * Created Time: 2022-12-23
+ * Author: haptear (haptear@hotmail.com)
+ */
+
+namespace hello_algo.chapter_computational_complexity;
+
+public class worst_best_time_complexity {
+    /* Создать массив с элементами { 1, 2, ..., n } в случайном порядке */
+    int[] RandomNumbers(int n) {
+        int[] nums = new int[n];
+        // Создать массив nums = { 1, 2, 3, ..., n }
+        for (int i = 0; i < n; i++) {
+            nums[i] = i + 1;
+        }
+
+        // Случайно перемешать элементы массива
+        for (int i = 0; i < nums.Length; i++) {
+            int index = new Random().Next(i, nums.Length);
+            (nums[i], nums[index]) = (nums[index], nums[i]);
+        }
+        return nums;
+    }
+
+    /* Найти индекс числа 1 в массиве nums */
+    int FindOne(int[] nums) {
+        for (int i = 0; i < nums.Length; i++) {
+            // Когда элемент 1 находится в начале массива, достигается лучшая временная сложность O(1)
+            // Когда элемент 1 находится в конце массива, достигается худшая временная сложность O(n)
+            if (nums[i] == 1)
+                return i;
+        }
+        return -1;
+    }
+
+
+    /* Driver Code */
+    [Test]
+    public void Test() {
+        for (int i = 0; i < 10; i++) {
+            int n = 100;
+            int[] nums = RandomNumbers(n);
+            int index = FindOne(nums);
+            Console.WriteLine("\nМассив [1, 2, ..., n] после перемешивания = " + string.Join(",", nums));
+            Console.WriteLine("Индекс числа 1 = " + index);
+        }
+    }
+}

ru/codes/csharp/chapter_divide_and_conquer/binary_search_recur.cs

@@ -0,0 +1,46 @@
+/**
+* File: binary_search_recur.cs
+* Created Time: 2023-07-18
+* Author: hpstory (hpstory1024@163.com)
+*/
+
+namespace hello_algo.chapter_divide_and_conquer;
+
+public class binary_search_recur {
+    /* Бинарный поиск: задача f(i, j) */
+    int DFS(int[] nums, int target, int i, int j) {
+        // Если интервал пуст, целевой элемент отсутствует, вернуть -1
+        if (i > j) {
+            return -1;
+        }
+        // Вычислить индекс середины m
+        int m = (i + j) / 2;
+        if (nums[m] < target) {
+            // Рекурсивная подзадача f(m+1, j)
+            return DFS(nums, target, m + 1, j);
+        } else if (nums[m] > target) {
+            // Рекурсивная подзадача f(i, m-1)
+            return DFS(nums, target, i, m - 1);
+        } else {
+            // Целевой элемент найден, вернуть его индекс
+            return m;
+        }
+    }
+
+    /* Бинарный поиск */
+    int BinarySearch(int[] nums, int target) {
+        int n = nums.Length;
+        // Решить задачу f(0, n-1)
+        return DFS(nums, target, 0, n - 1);
+    }
+
+    [Test]
+    public void Test() {
+        int target = 6;
+        int[] nums = [1, 3, 6, 8, 12, 15, 23, 26, 31, 35];
+
+        // Бинарный поиск (двусторонне замкнутый интервал)
+        int index = BinarySearch(nums, target);
+        Console.WriteLine("Индекс целевого элемента 6 = " + index);
+    }
+}

ru/codes/csharp/chapter_divide_and_conquer/build_tree.cs

@@ -0,0 +1,49 @@
+/**
+* File: build_tree.cs
+* Created Time: 2023-07-18
+* Author: hpstory (hpstory1024@163.com)
+*/
+
+namespace hello_algo.chapter_divide_and_conquer;
+
+public class build_tree {
+    /* Построить двоичное дерево: разделяй и властвуй */
+    TreeNode? DFS(int[] preorder, Dictionary<int, int> inorderMap, int i, int l, int r) {
+        // Завершить при пустом диапазоне поддерева
+        if (r - l < 0)
+            return null;
+        // Инициализировать корневой узел
+        TreeNode root = new(preorder[i]);
+        // Найти m, чтобы разделить левое и правое поддеревья
+        int m = inorderMap[preorder[i]];
+        // Подзадача: построить левое поддерево
+        root.left = DFS(preorder, inorderMap, i + 1, l, m - 1);
+        // Подзадача: построить правое поддерево
+        root.right = DFS(preorder, inorderMap, i + 1 + m - l, m + 1, r);
+        // Вернуть корневой узел
+        return root;
+    }
+
+    /* Построить двоичное дерево */
+    TreeNode? BuildTree(int[] preorder, int[] inorder) {
+        // Инициализировать хеш-таблицу для хранения соответствия элементов inorder их индексам
+        Dictionary<int, int> inorderMap = [];
+        for (int i = 0; i < inorder.Length; i++) {
+            inorderMap.TryAdd(inorder[i], i);
+        }
+        TreeNode? root = DFS(preorder, inorderMap, 0, 0, inorder.Length - 1);
+        return root;
+    }
+
+    [Test]
+    public void Test() {
+        int[] preorder = [3, 9, 2, 1, 7];
+        int[] inorder = [9, 3, 1, 2, 7];
+        Console.WriteLine("Предварительный обход = " + string.Join(", ", preorder));
+        Console.WriteLine("Симметричный обход = " + string.Join(", ", inorder));
+
+        TreeNode? root = BuildTree(preorder, inorder);
+        Console.WriteLine("Построенное двоичное дерево:");
+        PrintUtil.PrintTree(root);
+    }
+}

ru/codes/csharp/chapter_divide_and_conquer/hanota.cs

@@ -0,0 +1,59 @@
+/**
+* File: hanota.cs
+* Created Time: 2023-07-18
+* Author: hpstory (hpstory1024@163.com)
+*/
+
+namespace hello_algo.chapter_divide_and_conquer;
+
+public class hanota {
+    /* Переместить один диск */
+    void Move(List<int> src, List<int> tar) {
+        // Снять диск с вершины src
+        int pan = src[^1];
+        src.RemoveAt(src.Count - 1);
+        // Положить диск на вершину tar
+        tar.Add(pan);
+    }
+
+    /* Решить задачу Ханойской башни f(i) */
+    void DFS(int i, List<int> src, List<int> buf, List<int> tar) {
+        // Если в src остался только один диск, сразу переместить его в tar
+        if (i == 1) {
+            Move(src, tar);
+            return;
+        }
+        // Подзадача f(i-1): переместить верхние i-1 дисков из src в buf с помощью tar
+        DFS(i - 1, src, tar, buf);
+        // Подзадача f(1): переместить оставшийся один диск из src в tar
+        Move(src, tar);
+        // Подзадача f(i-1): переместить верхние i-1 дисков из buf в tar с помощью src
+        DFS(i - 1, buf, src, tar);
+    }
+
+    /* Решить задачу Ханойской башни */
+    void SolveHanota(List<int> A, List<int> B, List<int> C) {
+        int n = A.Count;
+        // Переместить верхние n дисков из A в C с помощью B
+        DFS(n, A, B, C);
+    }
+
+    [Test]
+    public void Test() {
+        // Хвост списка соответствует вершине столбца
+        List<int> A = [5, 4, 3, 2, 1];
+        List<int> B = [];
+        List<int> C = [];
+        Console.WriteLine("Исходное состояние:");
+        Console.WriteLine("A = " + string.Join(", ", A));
+        Console.WriteLine("B = " + string.Join(", ", B));
+        Console.WriteLine("C = " + string.Join(", ", C));
+
+        SolveHanota(A, B, C);
+
+        Console.WriteLine("После завершения перемещения дисков:");
+        Console.WriteLine("A = " + string.Join(", ", A));
+        Console.WriteLine("B = " + string.Join(", ", B));
+        Console.WriteLine("C = " + string.Join(", ", C));
+    }
+}

ru/codes/csharp/chapter_dynamic_programming/climbing_stairs_backtrack.cs

@@ -0,0 +1,41 @@
+/**
+* File: climbing_stairs_backtrack.cs
+* Created Time: 2023-06-30
+* Author: hpstory (hpstory1024@163.com)
+*/
+
+namespace hello_algo.chapter_dynamic_programming;
+
+public class climbing_stairs_backtrack {
+    /* Бэктрекинг */
+    void Backtrack(List<int> choices, int state, int n, List<int> res) {
+        // Когда подъем достигает n-й ступени, число вариантов увеличивается на 1
+        if (state == n)
+            res[0]++;
+        // Перебор всех вариантов выбора
+        foreach (int choice in choices) {
+            // Отсечение: нельзя выходить за n-ю ступень
+            if (state + choice > n)
+                continue;
+            // Попытка: сделать выбор и обновить состояние
+            Backtrack(choices, state + choice, n, res);
+            // Откат
+        }
+    }
+
+    /* Подъем по лестнице: бэктрекинг */
+    int ClimbingStairsBacktrack(int n) {
+        List<int> choices = [1, 2]; // Можно подняться на 1 или 2 ступени
+        int state = 0; // Начать подъем с 0-й ступени
+        List<int> res = [0]; // Использовать res[0] для хранения числа решений
+        Backtrack(choices, state, n, res);
+        return res[0];
+    }
+
+    [Test]
+    public void Test() {
+        int n = 9;
+        int res = ClimbingStairsBacktrack(n);
+        Console.WriteLine($"Количество способов подняться по лестнице из {n} ступеней = {res}");
+    }
+}

ru/codes/csharp/chapter_dynamic_programming/climbing_stairs_constraint_dp.cs

@@ -0,0 +1,36 @@
+/**
+* File: climbing_stairs_constraint_dp.cs
+* Created Time: 2023-07-03
+* Author: hpstory (hpstory1024@163.com)
+*/
+
+namespace hello_algo.chapter_dynamic_programming;
+
+public class climbing_stairs_constraint_dp {
+    /* Подъем по лестнице с ограничениями: динамическое программирование */
+    int ClimbingStairsConstraintDP(int n) {
+        if (n == 1 || n == 2) {
+            return 1;
+        }
+        // Инициализация таблицы dp для хранения решений подзадач
+        int[,] dp = new int[n + 1, 3];
+        // Начальное состояние: заранее задать решения наименьших подзадач
+        dp[1, 1] = 1;
+        dp[1, 2] = 0;
+        dp[2, 1] = 0;
+        dp[2, 2] = 1;
+        // Переход состояний: постепенное решение больших подзадач через меньшие
+        for (int i = 3; i <= n; i++) {
+            dp[i, 1] = dp[i - 1, 2];
+            dp[i, 2] = dp[i - 2, 1] + dp[i - 2, 2];
+        }
+        return dp[n, 1] + dp[n, 2];
+    }
+
+    [Test]
+    public void Test() {
+        int n = 9;
+        int res = ClimbingStairsConstraintDP(n);
+        Console.WriteLine($"Количество способов подняться по лестнице из {n} ступеней = {res}");
+    }
+}

ru/codes/csharp/chapter_dynamic_programming/climbing_stairs_dfs.cs

@@ -0,0 +1,31 @@
+/**
+* File: climbing_stairs_dfs.cs
+* Created Time: 2023-06-30
+* Author: hpstory (hpstory1024@163.com)
+*/
+
+namespace hello_algo.chapter_dynamic_programming;
+
+public class climbing_stairs_dfs {
+    /* Поиск */
+    int DFS(int i) {
+        // dp[1] и dp[2] уже известны, вернуть их
+        if (i == 1 || i == 2)
+            return i;
+        // dp[i] = dp[i-1] + dp[i-2]
+        int count = DFS(i - 1) + DFS(i - 2);
+        return count;
+    }
+
+    /* Подъем по лестнице: поиск */
+    int ClimbingStairsDFS(int n) {
+        return DFS(n);
+    }
+
+    [Test]
+    public void Test() {
+        int n = 9;
+        int res = ClimbingStairsDFS(n);
+        Console.WriteLine($"Количество способов подняться по лестнице из {n} ступеней = {res}");
+    }
+}

ru/codes/csharp/chapter_dynamic_programming/climbing_stairs_dfs_mem.cs

@@ -0,0 +1,39 @@
+/**
+* File: climbing_stairs_dfs_mem.cs
+* Created Time: 2023-06-30
+* Author: hpstory (hpstory1024@163.com)
+*/
+
+namespace hello_algo.chapter_dynamic_programming;
+
+public class climbing_stairs_dfs_mem {
+    /* Поиск с мемоизацией */
+    int DFS(int i, int[] mem) {
+        // dp[1] и dp[2] уже известны, вернуть их
+        if (i == 1 || i == 2)
+            return i;
+        // Если запись dp[i] существует, сразу вернуть ее
+        if (mem[i] != -1)
+            return mem[i];
+        // dp[i] = dp[i-1] + dp[i-2]
+        int count = DFS(i - 1, mem) + DFS(i - 2, mem);
+        // Сохранить dp[i]
+        mem[i] = count;
+        return count;
+    }
+
+    /* Подъем по лестнице: поиск с мемоизацией */
+    int ClimbingStairsDFSMem(int n) {
+        // mem[i] хранит число способов подняться на i-ю ступень, -1 означает отсутствие записи
+        int[] mem = new int[n + 1];
+        Array.Fill(mem, -1);
+        return DFS(n, mem);
+    }
+
+    [Test]
+    public void Test() {
+        int n = 9;
+        int res = ClimbingStairsDFSMem(n);
+        Console.WriteLine($"Количество способов подняться по лестнице из {n} ступеней = {res}");
+    }
+}

ru/codes/csharp/chapter_dynamic_programming/climbing_stairs_dp.cs

@@ -0,0 +1,49 @@
+/**
+* File: climbing_stairs_dp.cs
+* Created Time: 2023-06-30
+* Author: hpstory (hpstory1024@163.com)
+*/
+
+namespace hello_algo.chapter_dynamic_programming;
+
+public class climbing_stairs_dp {
+    /* Подъем по лестнице: динамическое программирование */
+    int ClimbingStairsDP(int n) {
+        if (n == 1 || n == 2)
+            return n;
+        // Инициализация таблицы dp для хранения решений подзадач
+        int[] dp = new int[n + 1];
+        // Начальное состояние: заранее задать решения наименьших подзадач
+        dp[1] = 1;
+        dp[2] = 2;
+        // Переход состояний: постепенное решение больших подзадач через меньшие
+        for (int i = 3; i <= n; i++) {
+            dp[i] = dp[i - 1] + dp[i - 2];
+        }
+        return dp[n];
+    }
+
+    /* Подъем по лестнице: динамическое программирование с оптимизацией памяти */
+    int ClimbingStairsDPComp(int n) {
+        if (n == 1 || n == 2)
+            return n;
+        int a = 1, b = 2;
+        for (int i = 3; i <= n; i++) {
+            int tmp = b;
+            b = a + b;
+            a = tmp;
+        }
+        return b;
+    }
+
+    [Test]
+    public void Test() {
+        int n = 9;
+
+        int res = ClimbingStairsDP(n);
+        Console.WriteLine($"Количество способов подняться по лестнице из {n} ступеней = {res}");
+
+        res = ClimbingStairsDPComp(n);
+        Console.WriteLine($"Количество способов подняться по лестнице из {n} ступеней = {res}");
+    }
+}

ru/codes/csharp/chapter_dynamic_programming/coin_change.cs

@@ -0,0 +1,71 @@
+/**
+* File: coin_change.cs
+* Created Time: 2023-07-12
+* Author: hpstory (hpstory1024@163.com)
+*/
+
+namespace hello_algo.chapter_dynamic_programming;
+
+public class coin_change {
+    /* Размен монет: динамическое программирование */
+    int CoinChangeDP(int[] coins, int amt) {
+        int n = coins.Length;
+        int MAX = amt + 1;
+        // Инициализация таблицы dp
+        int[,] dp = new int[n + 1, amt + 1];
+        // Переход состояний: первая строка и первый столбец
+        for (int a = 1; a <= amt; a++) {
+            dp[0, a] = MAX;
+        }
+        // Переход состояний: остальные строки и столбцы
+        for (int i = 1; i <= n; i++) {
+            for (int a = 1; a <= amt; a++) {
+                if (coins[i - 1] > a) {
+                    // Если целевая сумма превышена, монету i не выбирать
+                    dp[i, a] = dp[i - 1, a];
+                } else {
+                    // Меньшее из двух решений: не брать или взять монету i
+                    dp[i, a] = Math.Min(dp[i - 1, a], dp[i, a - coins[i - 1]] + 1);
+                }
+            }
+        }
+        return dp[n, amt] != MAX ? dp[n, amt] : -1;
+    }
+
+    /* Размен монет: динамическое программирование с оптимизацией памяти */
+    int CoinChangeDPComp(int[] coins, int amt) {
+        int n = coins.Length;
+        int MAX = amt + 1;
+        // Инициализация таблицы dp
+        int[] dp = new int[amt + 1];
+        Array.Fill(dp, MAX);
+        dp[0] = 0;
+        // Переход состояний
+        for (int i = 1; i <= n; i++) {
+            for (int a = 1; a <= amt; a++) {
+                if (coins[i - 1] > a) {
+                    // Если целевая сумма превышена, монету i не выбирать
+                    dp[a] = dp[a];
+                } else {
+                    // Меньшее из двух решений: не брать или взять монету i
+                    dp[a] = Math.Min(dp[a], dp[a - coins[i - 1]] + 1);
+                }
+            }
+        }
+        return dp[amt] != MAX ? dp[amt] : -1;
+    }
+
+    [Test]
+    public void Test() {
+        int[] coins = [1, 2, 5];
+        int amt = 4;
+
+        // Динамическое программирование
+        int res = CoinChangeDP(coins, amt);
+        Console.WriteLine("Минимальное число монет для набора целевой суммы = " + res);
+
+        // Динамическое программирование с оптимизацией памяти
+        res = CoinChangeDPComp(coins, amt);
+        Console.WriteLine("Минимальное число монет для набора целевой суммы = " + res);
+    }
+}

ru/codes/csharp/chapter_dynamic_programming/coin_change_ii.cs

@@ -0,0 +1,68 @@
+/**
+* File: coin_change_ii.cs
+* Created Time: 2023-07-12
+* Author: hpstory (hpstory1024@163.com)
+*/
+
+namespace hello_algo.chapter_dynamic_programming;
+
+public class coin_change_ii {
+    /* Размен монет II: динамическое программирование */
+    int CoinChangeIIDP(int[] coins, int amt) {
+        int n = coins.Length;
+        // Инициализация таблицы dp
+        int[,] dp = new int[n + 1, amt + 1];
+        // Инициализация первого столбца
+        for (int i = 0; i <= n; i++) {
+            dp[i, 0] = 1;
+        }
+        // Переход состояний
+        for (int i = 1; i <= n; i++) {
+            for (int a = 1; a <= amt; a++) {
+                if (coins[i - 1] > a) {
+                    // Если целевая сумма превышена, монету i не выбирать
+                    dp[i, a] = dp[i - 1, a];
+                } else {
+                    // Сумма двух решений: не брать или взять монету i
+                    dp[i, a] = dp[i - 1, a] + dp[i, a - coins[i - 1]];
+                }
+            }
+        }
+        return dp[n, amt];
+    }
+
+    /* Размен монет II: динамическое программирование с оптимизацией памяти */
+    int CoinChangeIIDPComp(int[] coins, int amt) {
+        int n = coins.Length;
+        // Инициализация таблицы dp
+        int[] dp = new int[amt + 1];
+        dp[0] = 1;
+        // Переход состояний
+        for (int i = 1; i <= n; i++) {
+            for (int a = 1; a <= amt; a++) {
+                if (coins[i - 1] > a) {
+                    // Если целевая сумма превышена, монету i не выбирать
+                    dp[a] = dp[a];
+                } else {
+                    // Сумма двух решений: не брать или взять монету i
+                    dp[a] = dp[a] + dp[a - coins[i - 1]];
+                }
+            }
+        }
+        return dp[amt];
+    }
+
+    [Test]
+    public void Test() {
+        int[] coins = [1, 2, 5];
+        int amt = 5;
+
+        // Динамическое программирование
+        int res = CoinChangeIIDP(coins, amt);
+        Console.WriteLine("Количество комбинаций монет для набора целевой суммы = " + res);
+
+        // Динамическое программирование с оптимизацией памяти
+        res = CoinChangeIIDPComp(coins, amt);
+        Console.WriteLine("Количество комбинаций монет для набора целевой суммы = " + res);
+    }
+}

ru/codes/csharp/chapter_dynamic_programming/edit_distance.cs

@@ -0,0 +1,141 @@
+/**
+* File: edit_distance.cs
+* Created Time: 2023-07-14
+* Author: hpstory (hpstory1024@163.com)
+*/
+
+namespace hello_algo.chapter_dynamic_programming;
+
+public class edit_distance {
+    /* Редакционное расстояние: полный перебор */
+    int EditDistanceDFS(string s, string t, int i, int j) {
+        // Если s и t пусты, вернуть 0
+        if (i == 0 && j == 0)
+            return 0;
+        // Если s пусто, вернуть длину t
+        if (i == 0)
+            return j;
+        // Если t пусто, вернуть длину s
+        if (j == 0)
+            return i;
+        // Если два символа равны, сразу пропустить их
+        if (s[i - 1] == t[j - 1])
+            return EditDistanceDFS(s, t, i - 1, j - 1);
+        // Минимальное число шагов редактирования = минимальное число шагов для вставки, удаления и замены + 1
+        int insert = EditDistanceDFS(s, t, i, j - 1);
+        int delete = EditDistanceDFS(s, t, i - 1, j);
+        int replace = EditDistanceDFS(s, t, i - 1, j - 1);
+        // Вернуть минимальное число шагов редактирования
+        return Math.Min(Math.Min(insert, delete), replace) + 1;
+    }
+
+    /* Редакционное расстояние: поиск с мемоизацией */
+    int EditDistanceDFSMem(string s, string t, int[][] mem, int i, int j) {
+        // Если s и t пусты, вернуть 0
+        if (i == 0 && j == 0)
+            return 0;
+        // Если s пусто, вернуть длину t
+        if (i == 0)
+            return j;
+        // Если t пусто, вернуть длину s
+        if (j == 0)
+            return i;
+        // Если запись уже есть, сразу вернуть ее
+        if (mem[i][j] != -1)
+            return mem[i][j];
+        // Если два символа равны, сразу пропустить их
+        if (s[i - 1] == t[j - 1])
+            return EditDistanceDFSMem(s, t, mem, i - 1, j - 1);
+        // Минимальное число шагов редактирования = минимальное число шагов для вставки, удаления и замены + 1
+        int insert = EditDistanceDFSMem(s, t, mem, i, j - 1);
+        int delete = EditDistanceDFSMem(s, t, mem, i - 1, j);
+        int replace = EditDistanceDFSMem(s, t, mem, i - 1, j - 1);
+        // Сохранить и вернуть минимальное число шагов редактирования
+        mem[i][j] = Math.Min(Math.Min(insert, delete), replace) + 1;
+        return mem[i][j];
+    }
+
+    /* Редакционное расстояние: динамическое программирование */
+    int EditDistanceDP(string s, string t) {
+        int n = s.Length, m = t.Length;
+        int[,] dp = new int[n + 1, m + 1];
+        // Переход состояний: первая строка и первый столбец
+        for (int i = 1; i <= n; i++) {
+            dp[i, 0] = i;
+        }
+        for (int j = 1; j <= m; j++) {
+            dp[0, j] = j;
+        }
+        // Переход состояний: остальные строки и столбцы
+        for (int i = 1; i <= n; i++) {
+            for (int j = 1; j <= m; j++) {
+                if (s[i - 1] == t[j - 1]) {
+                    // Если два символа равны, сразу пропустить их
+                    dp[i, j] = dp[i - 1, j - 1];
+                } else {
+                    // Минимальное число шагов редактирования = минимальное число шагов для вставки, удаления и замены + 1
+                    dp[i, j] = Math.Min(Math.Min(dp[i, j - 1], dp[i - 1, j]), dp[i - 1, j - 1]) + 1;
+                }
+            }
+        }
+        return dp[n, m];
+    }
+
+    /* Редакционное расстояние: динамическое программирование с оптимизацией памяти */
+    int EditDistanceDPComp(string s, string t) {
+        int n = s.Length, m = t.Length;
+        int[] dp = new int[m + 1];
+        // Переход состояний: первая строка
+        for (int j = 1; j <= m; j++) {
+            dp[j] = j;
+        }
+        // Переход состояний: остальные строки
+        for (int i = 1; i <= n; i++) {
+            // Переход состояний: первый столбец
+            int leftup = dp[0]; // Временно сохранить dp[i-1, j-1]
+            dp[0] = i;
+            // Переход состояний: остальные столбцы
+            for (int j = 1; j <= m; j++) {
+                int temp = dp[j];
+                if (s[i - 1] == t[j - 1]) {
+                    // Если два символа равны, сразу пропустить их
+                    dp[j] = leftup;
+                } else {
+                    // Минимальное число шагов редактирования = минимальное число шагов для вставки, удаления и замены + 1
+                    dp[j] = Math.Min(Math.Min(dp[j - 1], dp[j]), leftup) + 1;
+                }
+                leftup = temp; // Обновить до значения dp[i-1, j-1] для следующей итерации
+            }
+        }
+        return dp[m];
+    }
+
+    [Test]
+    public void Test() {
+        string s = "bag";
+        string t = "pack";
+        int n = s.Length, m = t.Length;
+
+        // Полный перебор
+        int res = EditDistanceDFS(s, t, n, m);
+        Console.WriteLine("Чтобы преобразовать " + s + " в " + t + ", нужно минимум " + res + " шагов редактирования");
+
+        // Поиск с мемоизацией
+        int[][] mem = new int[n + 1][];
+        for (int i = 0; i <= n; i++) {
+            mem[i] = new int[m + 1];
+            Array.Fill(mem[i], -1);
+        }
+
+        res = EditDistanceDFSMem(s, t, mem, n, m);
+        Console.WriteLine("Чтобы преобразовать " + s + " в " + t + ", нужно минимум " + res + " шагов редактирования");
+
+        // Динамическое программирование
+        res = EditDistanceDP(s, t);
+        Console.WriteLine("Чтобы преобразовать " + s + " в " + t + ", нужно минимум " + res + " шагов редактирования");
+
+        // Динамическое программирование с оптимизацией памяти
+        res = EditDistanceDPComp(s, t);
+        Console.WriteLine("Чтобы преобразовать " + s + " в " + t + ", нужно минимум " + res + " шагов редактирования");
+    }
+}

ru/codes/csharp/chapter_dynamic_programming/knapsack.cs

@@ -0,0 +1,118 @@
+/**
+* File: knapsack.cs
+* Created Time: 2023-07-07
+* Author: hpstory (hpstory1024@163.com)
+*/
+
+namespace hello_algo.chapter_dynamic_programming;
+
+public class knapsack {
+    /* Рюкзак 0-1: полный перебор */
+    int KnapsackDFS(int[] weight, int[] val, int i, int c) {
+        // Если все предметы уже рассмотрены или в рюкзаке не осталось места, вернуть стоимость 0
+        if (i == 0 || c == 0) {
+            return 0;
+        }
+        // Если вместимость рюкзака превышена, можно только не класть предмет в рюкзак
+        if (weight[i - 1] > c) {
+            return KnapsackDFS(weight, val, i - 1, c);
+        }
+        // Вычислить максимальную стоимость для случаев, когда предмет i не кладут и кладут
+        int no = KnapsackDFS(weight, val, i - 1, c);
+        int yes = KnapsackDFS(weight, val, i - 1, c - weight[i - 1]) + val[i - 1];
+        // Вернуть вариант с большей стоимостью из двух возможных
+        return Math.Max(no, yes);
+    }
+
+    /* Рюкзак 0-1: поиск с мемоизацией */
+    int KnapsackDFSMem(int[] weight, int[] val, int[][] mem, int i, int c) {
+        // Если все предметы уже рассмотрены или в рюкзаке не осталось места, вернуть стоимость 0
+        if (i == 0 || c == 0) {
+            return 0;
+        }
+        // Если запись уже есть, вернуть сразу
+        if (mem[i][c] != -1) {
+            return mem[i][c];
+        }
+        // Если вместимость рюкзака превышена, можно только не класть предмет в рюкзак
+        if (weight[i - 1] > c) {
+            return KnapsackDFSMem(weight, val, mem, i - 1, c);
+        }
+        // Вычислить максимальную стоимость для случаев, когда предмет i не кладут и кладут
+        int no = KnapsackDFSMem(weight, val, mem, i - 1, c);
+        int yes = KnapsackDFSMem(weight, val, mem, i - 1, c - weight[i - 1]) + val[i - 1];
+        // Сохранить и вернуть вариант с большей стоимостью из двух решений
+        mem[i][c] = Math.Max(no, yes);
+        return mem[i][c];
+    }
+
+    /* Рюкзак 0-1: динамическое программирование */
+    int KnapsackDP(int[] weight, int[] val, int cap) {
+        int n = weight.Length;
+        // Инициализация таблицы dp
+        int[,] dp = new int[n + 1, cap + 1];
+        // Переход состояний
+        for (int i = 1; i <= n; i++) {
+            for (int c = 1; c <= cap; c++) {
+                if (weight[i - 1] > c) {
+                    // Если вместимость рюкзака превышена, предмет i не выбирать
+                    dp[i, c] = dp[i - 1, c];
+                } else {
+                    // Большее из двух решений: не брать или взять предмет i
+                    dp[i, c] = Math.Max(dp[i - 1, c - weight[i - 1]] + val[i - 1], dp[i - 1, c]);
+                }
+            }
+        }
+        return dp[n, cap];
+    }
+
+    /* Рюкзак 0-1: динамическое программирование с оптимизацией памяти */
+    int KnapsackDPComp(int[] weight, int[] val, int cap) {
+        int n = weight.Length;
+        // Инициализация таблицы dp
+        int[] dp = new int[cap + 1];
+        // Переход состояний
+        for (int i = 1; i <= n; i++) {
+            // Обход в обратном порядке
+            for (int c = cap; c > 0; c--) {
+                if (weight[i - 1] > c) {
+                    // Если вместимость рюкзака превышена, предмет i не выбирать
+                    dp[c] = dp[c];
+                } else {
+                    // Большее из двух решений: не брать или взять предмет i
+                    dp[c] = Math.Max(dp[c], dp[c - weight[i - 1]] + val[i - 1]);
+                }
+            }
+        }
+        return dp[cap];
+    }
+
+    [Test]
+    public void Test() {
+        int[] weight = [10, 20, 30, 40, 50];
+        int[] val = [50, 120, 150, 210, 240];
+        int cap = 50;
+        int n = weight.Length;
+
+        // Полный перебор
+        int res = KnapsackDFS(weight, val, n, cap);
+        Console.WriteLine("Максимальная стоимость предметов без превышения вместимости рюкзака = " + res);
+
+        // Поиск с мемоизацией
+        int[][] mem = new int[n + 1][];
+        for (int i = 0; i <= n; i++) {
+            mem[i] = new int[cap + 1];
+            Array.Fill(mem[i], -1);
+        }
+        res = KnapsackDFSMem(weight, val, mem, n, cap);
+        Console.WriteLine("Максимальная стоимость предметов без превышения вместимости рюкзака = " + res);
+
+        // Динамическое программирование
+        res = KnapsackDP(weight, val, cap);
+        Console.WriteLine("Максимальная стоимость предметов без превышения вместимости рюкзака = " + res);
+
+        // Динамическое программирование с оптимизацией памяти
+        res = KnapsackDPComp(weight, val, cap);
+        Console.WriteLine("Максимальная стоимость предметов без превышения вместимости рюкзака = " + res);
+    }
+}

ru/codes/csharp/chapter_dynamic_programming/min_cost_climbing_stairs_dp.cs

@@ -0,0 +1,53 @@
+/**
+* File: min_cost_climbing_stairs_dp.cs
+* Created Time: 2023-06-30
+* Author: hpstory (hpstory1024@163.com)
+*/
+
+namespace hello_algo.chapter_dynamic_programming;
+
+public class min_cost_climbing_stairs_dp {
+    /* Минимальная стоимость подъема по лестнице: динамическое программирование */
+    int MinCostClimbingStairsDP(int[] cost) {
+        int n = cost.Length - 1;
+        if (n == 1 || n == 2)
+            return cost[n];
+        // Инициализация таблицы dp для хранения решений подзадач
+        int[] dp = new int[n + 1];
+        // Начальное состояние: заранее задать решения наименьших подзадач
+        dp[1] = cost[1];
+        dp[2] = cost[2];
+        // Переход состояний: постепенное решение больших подзадач через меньшие
+        for (int i = 3; i <= n; i++) {
+            dp[i] = Math.Min(dp[i - 1], dp[i - 2]) + cost[i];
+        }
+        return dp[n];
+    }
+
+    /* Минимальная стоимость подъема по лестнице: динамическое программирование с оптимизацией памяти */
+    int MinCostClimbingStairsDPComp(int[] cost) {
+        int n = cost.Length - 1;
+        if (n == 1 || n == 2)
+            return cost[n];
+        int a = cost[1], b = cost[2];
+        for (int i = 3; i <= n; i++) {
+            int tmp = b;
+            b = Math.Min(a, tmp) + cost[i];
+            a = tmp;
+        }
+        return b;
+    }
+
+    [Test]
+    public void Test() {
+        int[] cost = [0, 1, 10, 1, 1, 1, 10, 1, 1, 10, 1];
+        Console.WriteLine("Список стоимостей ступеней:");
+        PrintUtil.PrintList(cost);
+
+        int res = MinCostClimbingStairsDP(cost);
+        Console.WriteLine($"Минимальная стоимость подъема по лестнице = {res}");
+
+        res = MinCostClimbingStairsDPComp(cost);
+        Console.WriteLine($"Минимальная стоимость подъема по лестнице = {res}");
+    }
+}

ru/codes/csharp/chapter_dynamic_programming/min_path_sum.cs

@@ -0,0 +1,127 @@
+/**
+* File: min_path_sum.cs
+* Created Time: 2023-07-10
+* Author: hpstory (hpstory1024@163.com)
+*/
+
+namespace hello_algo.chapter_dynamic_programming;
+
+public class min_path_sum {
+    /* Минимальная сумма пути: полный перебор */
+    int MinPathSumDFS(int[][] grid, int i, int j) {
+        // Если это верхняя левая ячейка, завершить поиск
+        if (i == 0 && j == 0) {
+            return grid[0][0];
+        }
+        // Если индексы строки или столбца выходят за границы, вернуть стоимость +∞
+        if (i < 0 || j < 0) {
+            return int.MaxValue;
+        }
+        // Вычислить минимальную стоимость пути из левого верхнего угла до (i-1, j) и (i, j-1)
+        int up = MinPathSumDFS(grid, i - 1, j);
+        int left = MinPathSumDFS(grid, i, j - 1);
+        // Вернуть минимальную стоимость пути из левого верхнего угла до (i, j)
+        return Math.Min(left, up) + grid[i][j];
+    }
+
+    /* Минимальная сумма пути: поиск с мемоизацией */
+    int MinPathSumDFSMem(int[][] grid, int[][] mem, int i, int j) {
+        // Если это верхняя левая ячейка, завершить поиск
+        if (i == 0 && j == 0) {
+            return grid[0][0];
+        }
+        // Если индексы строки или столбца выходят за границы, вернуть стоимость +∞
+        if (i < 0 || j < 0) {
+            return int.MaxValue;
+        }
+        // Если запись уже есть, вернуть сразу
+        if (mem[i][j] != -1) {
+            return mem[i][j];
+        }
+        // Минимальная стоимость пути для левой и верхней ячеек
+        int up = MinPathSumDFSMem(grid, mem, i - 1, j);
+        int left = MinPathSumDFSMem(grid, mem, i, j - 1);
+        // Сохранить и вернуть минимальную стоимость пути из левого верхнего угла до (i, j)
+        mem[i][j] = Math.Min(left, up) + grid[i][j];
+        return mem[i][j];
+    }
+
+    /* Минимальная сумма пути: динамическое программирование */
+    int MinPathSumDP(int[][] grid) {
+        int n = grid.Length, m = grid[0].Length;
+        // Инициализация таблицы dp
+        int[,] dp = new int[n, m];
+        dp[0, 0] = grid[0][0];
+        // Переход состояний: первая строка
+        for (int j = 1; j < m; j++) {
+            dp[0, j] = dp[0, j - 1] + grid[0][j];
+        }
+        // Переход состояний: первый столбец
+        for (int i = 1; i < n; i++) {
+            dp[i, 0] = dp[i - 1, 0] + grid[i][0];
+        }
+        // Переход состояний: остальные строки и столбцы
+        for (int i = 1; i < n; i++) {
+            for (int j = 1; j < m; j++) {
+                dp[i, j] = Math.Min(dp[i, j - 1], dp[i - 1, j]) + grid[i][j];
+            }
+        }
+        return dp[n - 1, m - 1];
+    }
+
+    /* Минимальная сумма пути: динамическое программирование с оптимизацией памяти */
+    int MinPathSumDPComp(int[][] grid) {
+        int n = grid.Length, m = grid[0].Length;
+        // Инициализация таблицы dp
+        int[] dp = new int[m];
+        dp[0] = grid[0][0];
+        // Переход состояний: первая строка
+        for (int j = 1; j < m; j++) {
+            dp[j] = dp[j - 1] + grid[0][j];
+        }
+        // Переход состояний: остальные строки
+        for (int i = 1; i < n; i++) {
+            // Переход состояний: первый столбец
+            dp[0] = dp[0] + grid[i][0];
+            // Переход состояний: остальные столбцы
+            for (int j = 1; j < m; j++) {
+                dp[j] = Math.Min(dp[j - 1], dp[j]) + grid[i][j];
+            }
+        }
+        return dp[m - 1];
+    }
+
+    [Test]
+    public void Test() {
+        int[][] grid =
+        [
+            [1, 3, 1, 5],
+            [2, 2, 4, 2],
+            [5, 3, 2, 1],
+            [4, 3, 5, 2]
+        ];
+
+        int n = grid.Length, m = grid[0].Length;
+
+        // Полный перебор
+        int res = MinPathSumDFS(grid, n - 1, m - 1);
+        Console.WriteLine("Минимальная сумма пути из левого верхнего угла в правый нижний = " + res);
+
+        // Поиск с мемоизацией
+        int[][] mem = new int[n][];
+        for (int i = 0; i < n; i++) {
+            mem[i] = new int[m];
+            Array.Fill(mem[i], -1);
+        }
+        res = MinPathSumDFSMem(grid, mem, n - 1, m - 1);
+        Console.WriteLine("Минимальная сумма пути из левого верхнего угла в правый нижний = " + res);
+
+        // Динамическое программирование
+        res = MinPathSumDP(grid);
+        Console.WriteLine("Минимальная сумма пути из левого верхнего угла в правый нижний = " + res);
+
+        // Динамическое программирование с оптимизацией памяти
+        res = MinPathSumDPComp(grid);
+        Console.WriteLine("Минимальная сумма пути из левого верхнего угла в правый нижний = " + res);
+    }
+}

ru/codes/csharp/chapter_dynamic_programming/unbounded_knapsack.cs

@@ -0,0 +1,64 @@
+/**
+* File: unbounded_knapsack.cs
+* Created Time: 2023-07-12
+* Author: hpstory (hpstory1024@163.com)
+*/
+
+namespace hello_algo.chapter_dynamic_programming;
+
+public class unbounded_knapsack {
+    /* Полный рюкзак: динамическое программирование */
+    int UnboundedKnapsackDP(int[] wgt, int[] val, int cap) {
+        int n = wgt.Length;
+        // Инициализация таблицы dp
+        int[,] dp = new int[n + 1, cap + 1];
+        // Переход состояний
+        for (int i = 1; i <= n; i++) {
+            for (int c = 1; c <= cap; c++) {
+                if (wgt[i - 1] > c) {
+                    // Если вместимость рюкзака превышена, предмет i не выбирать
+                    dp[i, c] = dp[i - 1, c];
+                } else {
+                    // Большее из двух решений: не брать или взять предмет i
+                    dp[i, c] = Math.Max(dp[i - 1, c], dp[i, c - wgt[i - 1]] + val[i - 1]);
+                }
+            }
+        }
+        return dp[n, cap];
+    }
+
+    /* Полный рюкзак: динамическое программирование с оптимизацией памяти */
+    int UnboundedKnapsackDPComp(int[] wgt, int[] val, int cap) {
+        int n = wgt.Length;
+        // Инициализация таблицы dp
+        int[] dp = new int[cap + 1];
+        // Переход состояний
+        for (int i = 1; i <= n; i++) {
+            for (int c = 1; c <= cap; c++) {
+                if (wgt[i - 1] > c) {
+                    // Если вместимость рюкзака превышена, предмет i не выбирать
+                    dp[c] = dp[c];
+                } else {
+                    // Большее из двух решений: не брать или взять предмет i
+                    dp[c] = Math.Max(dp[c], dp[c - wgt[i - 1]] + val[i - 1]);
+                }
+            }
+        }
+        return dp[cap];
+    }
+
+    [Test]
+    public void Test() {
+        int[] wgt = [1, 2, 3];
+        int[] val = [5, 11, 15];
+        int cap = 4;
+
+        // Динамическое программирование
+        int res = UnboundedKnapsackDP(wgt, val, cap);
+        Console.WriteLine("Максимальная стоимость предметов без превышения вместимости рюкзака = " + res);
+
+        // Динамическое программирование с оптимизацией памяти
+        res = UnboundedKnapsackDPComp(wgt, val, cap);
+        Console.WriteLine("Максимальная стоимость предметов без превышения вместимости рюкзака = " + res);
+    }
+}

ru/codes/csharp/chapter_graph/graph_adjacency_list.cs

@@ -0,0 +1,122 @@
+/**
+ * File: graph_adjacency_list.cs
+ * Created Time: 2023-02-06
+ * Author: zjkung1123 (zjkung1123@gmail.com)
+ */
+
+namespace hello_algo.chapter_graph;
+
+/* Класс неориентированного графа на основе списка смежности */
+public class GraphAdjList {
+    // Список смежности, где key — вершина, а value — все смежные ей вершины
+    public Dictionary<Vertex, List<Vertex>> adjList;
+
+    /* Конструктор */
+    public GraphAdjList(Vertex[][] edges) {
+        adjList = [];
+        // Добавить все вершины и ребра
+        foreach (Vertex[] edge in edges) {
+            AddVertex(edge[0]);
+            AddVertex(edge[1]);
+            AddEdge(edge[0], edge[1]);
+        }
+    }
+
+    /* Получить число вершин */
+    int Size() {
+        return adjList.Count;
+    }
+
+    /* Добавление ребра */
+    public void AddEdge(Vertex vet1, Vertex vet2) {
+        if (!adjList.ContainsKey(vet1) || !adjList.ContainsKey(vet2) || vet1 == vet2)
+            throw new InvalidOperationException();
+        // Добавить ребро vet1 - vet2
+        adjList[vet1].Add(vet2);
+        adjList[vet2].Add(vet1);
+    }
+
+    /* Удаление ребра */
+    public void RemoveEdge(Vertex vet1, Vertex vet2) {
+        if (!adjList.ContainsKey(vet1) || !adjList.ContainsKey(vet2) || vet1 == vet2)
+            throw new InvalidOperationException();
+        // Удалить ребро vet1 - vet2
+        adjList[vet1].Remove(vet2);
+        adjList[vet2].Remove(vet1);
+    }
+
+    /* Добавление вершины */
+    public void AddVertex(Vertex vet) {
+        if (adjList.ContainsKey(vet))
+            return;
+        // Добавить новый список в список смежности
+        adjList.Add(vet, []);
+    }
+
+    /* Удаление вершины */
+    public void RemoveVertex(Vertex vet) {
+        if (!adjList.ContainsKey(vet))
+            throw new InvalidOperationException();
+        // Удалить из списка смежности список, соответствующий вершине vet
+        adjList.Remove(vet);
+        // Обойти списки других вершин и удалить все ребра, содержащие vet
+        foreach (List<Vertex> list in adjList.Values) {
+            list.Remove(vet);
+        }
+    }
+
+    /* Вывести список смежности */
+    public void Print() {
+        Console.WriteLine("Список смежности =");
+        foreach (KeyValuePair<Vertex, List<Vertex>> pair in adjList) {
+            List<int> tmp = [];
+            foreach (Vertex vertex in pair.Value)
+                tmp.Add(vertex.val);
+            Console.WriteLine(pair.Key.val + ": [" + string.Join(", ", tmp) + "],");
+        }
+    }
+}
+
+public class graph_adjacency_list {
+    [Test]
+    public void Test() {
+        /* Инициализация неориентированного графа */
+        Vertex[] v = Vertex.ValsToVets([1, 3, 2, 5, 4]);
+        Vertex[][] edges =
+        [
+            [v[0], v[1]],
+            [v[0], v[3]],
+            [v[1], v[2]],
+            [v[2], v[3]],
+            [v[2], v[4]],
+            [v[3], v[4]] 
+        ];
+        GraphAdjList graph = new(edges);
+        Console.WriteLine("\nГраф после инициализации");
+        graph.Print();
+
+        /* Добавление ребра */
+        // Вершины 1 и 2 соответствуют v[0] и v[2]
+        graph.AddEdge(v[0], v[2]);
+        Console.WriteLine("\nГраф после добавления ребра 1-2");
+        graph.Print();
+
+        /* Удаление ребра */
+        // Вершины 1 и 3 соответствуют v[0] и v[1]
+        graph.RemoveEdge(v[0], v[1]);
+        Console.WriteLine("\nГраф после удаления ребра 1-3");
+        graph.Print();
+
+        /* Добавление вершины */
+        Vertex v5 = new(6);
+        graph.AddVertex(v5);
+        Console.WriteLine("\nГраф после добавления вершины 6");
+        graph.Print();
+
+        /* Удаление вершины */
+        // Вершина 3 соответствует v[1]
+        graph.RemoveVertex(v[1]);
+        Console.WriteLine("\nГраф после удаления вершины 3");
+        graph.Print();
+    }
+}

ru/codes/csharp/chapter_graph/graph_adjacency_matrix.cs

@@ -0,0 +1,137 @@
+/**
+ * File: graph_adjacency_matrix.cs
+ * Created Time: 2023-02-06
+ * Author: zjkung1123 (zjkung1123@gmail.com)
+ */
+
+namespace hello_algo.chapter_graph;
+
+/* Класс неориентированного графа на основе матрицы смежности */
+class GraphAdjMat {
+    List<int> vertices;     // Список вершин: элементы представляют «значения вершин», а индексы — «индексы вершин»
+    List<List<int>> adjMat; // Матрица смежности, где индексы строк и столбцов соответствуют «индексам вершин»
+
+    /* Конструктор */
+    public GraphAdjMat(int[] vertices, int[][] edges) {
+        this.vertices = [];
+        this.adjMat = [];
+        // Добавление вершины
+        foreach (int val in vertices) {
+            AddVertex(val);
+        }
+        // Добавить ребра
+        // Обратите внимание: элементы edges представляют собой индексы вершин, то есть соответствуют индексам элементов vertices
+        foreach (int[] e in edges) {
+            AddEdge(e[0], e[1]);
+        }
+    }
+
+    /* Получить число вершин */
+    int Size() {
+        return vertices.Count;
+    }
+
+    /* Добавление вершины */
+    public void AddVertex(int val) {
+        int n = Size();
+        // Добавить значение новой вершины в список вершин
+        vertices.Add(val);
+        // Добавить строку в матрицу смежности
+        List<int> newRow = new(n);
+        for (int j = 0; j < n; j++) {
+            newRow.Add(0);
+        }
+        adjMat.Add(newRow);
+        // Добавить столбец в матрицу смежности
+        foreach (List<int> row in adjMat) {
+            row.Add(0);
+        }
+    }
+
+    /* Удаление вершины */
+    public void RemoveVertex(int index) {
+        if (index >= Size())
+            throw new IndexOutOfRangeException();
+        // Удалить вершину с индексом index из списка вершин
+        vertices.RemoveAt(index);
+        // Удалить строку с индексом index из матрицы смежности
+        adjMat.RemoveAt(index);
+        // Удалить столбец с индексом index из матрицы смежности
+        foreach (List<int> row in adjMat) {
+            row.RemoveAt(index);
+        }
+    }
+
+    /* Добавление ребра */
+    // Параметры i и j соответствуют индексам элементов vertices
+    public void AddEdge(int i, int j) {
+        // Обработка выхода индекса за границы и случая равенства
+        if (i < 0 || j < 0 || i >= Size() || j >= Size() || i == j)
+            throw new IndexOutOfRangeException();
+        // В неориентированном графе матрица смежности симметрична относительно главной диагонали, то есть выполняется (i, j) == (j, i)
+        adjMat[i][j] = 1;
+        adjMat[j][i] = 1;
+    }
+
+    /* Удаление ребра */
+    // Параметры i и j соответствуют индексам элементов vertices
+    public void RemoveEdge(int i, int j) {
+        // Обработка выхода индекса за границы и случая равенства
+        if (i < 0 || j < 0 || i >= Size() || j >= Size() || i == j)
+            throw new IndexOutOfRangeException();
+        adjMat[i][j] = 0;
+        adjMat[j][i] = 0;
+    }
+
+    /* Вывести матрицу смежности */
+    public void Print() {
+        Console.Write("Список вершин = ");
+        PrintUtil.PrintList(vertices);
+        Console.WriteLine("Матрица смежности =");
+        PrintUtil.PrintMatrix(adjMat);
+    }
+}
+
+public class graph_adjacency_matrix {
+    [Test]
+    public void Test() {
+        /* Инициализация неориентированного графа */
+        // Обратите внимание: элементы edges представляют индексы вершин, то есть соответствуют индексам элементов vertices
+        int[] vertices = [1, 3, 2, 5, 4];
+        int[][] edges = 
+        [
+            [0, 1],
+            [0, 3],
+            [1, 2],
+            [2, 3],
+            [2, 4],
+            [3, 4]
+        ];
+        GraphAdjMat graph = new(vertices, edges);
+        Console.WriteLine("\nГраф после инициализации");
+        graph.Print();
+
+        /* Добавление ребра */
+        // Индексы вершин 1 и 2 равны 0 и 2 соответственно
+        graph.AddEdge(0, 2);
+        Console.WriteLine("\nГраф после добавления ребра 1-2");
+        graph.Print();
+
+        /* Удаление ребра */
+        // Индексы вершин 1 и 3 равны 0 и 1 соответственно
+        graph.RemoveEdge(0, 1);
+        Console.WriteLine("\nГраф после удаления ребра 1-3");
+        graph.Print();
+
+        /* Добавление вершины */
+        graph.AddVertex(6);
+        Console.WriteLine("\nГраф после добавления вершины 6");
+        graph.Print();
+
+        /* Удаление вершины */
+        // Индекс вершины 3 равен 1
+        graph.RemoveVertex(1);
+        Console.WriteLine("\nГраф после удаления вершины 3");
+        graph.Print();
+    }
+}

ru/codes/csharp/chapter_graph/graph_bfs.cs

@@ -0,0 +1,58 @@
+/**
+ * File: graph_bfs.cs
+ * Created Time: 2023-03-08
+ * Author: hpstory (hpstory1024@163.com)
+ */
+
+namespace hello_algo.chapter_graph;
+
+public class graph_bfs {
+    /* Обход в ширину */
+    // Использовать список смежности для представления графа, чтобы получить все смежные вершины заданной вершины
+    List<Vertex> GraphBFS(GraphAdjList graph, Vertex startVet) {
+        // Последовательность обхода вершин
+        List<Vertex> res = [];
+        // Хеш-множество для хранения уже посещенных вершин
+        HashSet<Vertex> visited = [startVet];
+        // Очередь используется для реализации BFS
+        Queue<Vertex> que = new();
+        que.Enqueue(startVet);
+        // Начиная с вершины vet, продолжать цикл, пока не будут посещены все вершины
+        while (que.Count > 0) {
+            Vertex vet = que.Dequeue(); // Извлечь головную вершину из очереди
+            res.Add(vet);               // Отметить посещенную вершину
+            foreach (Vertex adjVet in graph.adjList[vet]) {
+                if (visited.Contains(adjVet)) {
+                    continue;          // Пропустить уже посещенную вершину
+                }
+                que.Enqueue(adjVet);   // Помещать в очередь только непосещенные вершины
+                visited.Add(adjVet);   // Отметить эту вершину как посещенную
+            }
+        }
+
+        // Вернуть последовательность обхода вершин
+        return res;
+    }
+
+    [Test]
+    public void Test() {
+        /* Инициализация неориентированного графа */
+        Vertex[] v = Vertex.ValsToVets([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]);
+        Vertex[][] edges =
+        [
+            [v[0], v[1]], [v[0], v[3]], [v[1], v[2]],
+            [v[1], v[4]], [v[2], v[5]], [v[3], v[4]],
+            [v[3], v[6]], [v[4], v[5]], [v[4], v[7]],
+            [v[5], v[8]], [v[6], v[7]], [v[7], v[8]]
+        ];
+
+        GraphAdjList graph = new(edges);
+        Console.WriteLine("\nГраф после инициализации");
+        graph.Print();
+
+        /* Обход в ширину */
+        List<Vertex> res = GraphBFS(graph, v[0]);
+        Console.WriteLine("\nПоследовательность вершин при обходе в ширину (BFS)");
+        Console.WriteLine(string.Join(" ", Vertex.VetsToVals(res)));
+    }
+}

ru/codes/csharp/chapter_graph/graph_dfs.cs

@@ -0,0 +1,54 @@
+/**
+ * File: graph_dfs.cs
+ * Created Time: 2023-03-08
+ * Author: hpstory (hpstory1024@163.com)
+ */
+
+namespace hello_algo.chapter_graph;
+
+public class graph_dfs {
+    /* Вспомогательная функция обхода в глубину */
+    void DFS(GraphAdjList graph, HashSet<Vertex> visited, List<Vertex> res, Vertex vet) {
+        res.Add(vet);     // Отметить посещенную вершину
+        visited.Add(vet); // Отметить эту вершину как посещенную
+        // Обойти все смежные вершины данной вершины
+        foreach (Vertex adjVet in graph.adjList[vet]) {
+            if (visited.Contains(adjVet)) {
+                continue; // Пропустить уже посещенную вершину
+            }
+            // Рекурсивно обходить смежные вершины
+            DFS(graph, visited, res, adjVet);
+        }
+    }
+
+    /* Обход в глубину */
+    // Использовать список смежности для представления графа, чтобы получить все смежные вершины заданной вершины
+    List<Vertex> GraphDFS(GraphAdjList graph, Vertex startVet) {
+        // Последовательность обхода вершин
+        List<Vertex> res = [];
+        // Хеш-множество для хранения уже посещенных вершин
+        HashSet<Vertex> visited = [];
+        DFS(graph, visited, res, startVet);
+        return res;
+    }
+
+    [Test]
+    public void Test() {
+        /* Инициализация неориентированного графа */
+        Vertex[] v = Vertex.ValsToVets([0, 1, 2, 3, 4, 5, 6]);
+        Vertex[][] edges =
+        [
+            [v[0], v[1]], [v[0], v[3]], [v[1], v[2]],
+            [v[2], v[5]], [v[4], v[5]], [v[5], v[6]],
+        ];
+
+        GraphAdjList graph = new(edges);
+        Console.WriteLine("\nГраф после инициализации");
+        graph.Print();
+
+        /* Обход в глубину */
+        List<Vertex> res = GraphDFS(graph, v[0]);
+        Console.WriteLine("\nПоследовательность вершин при обходе в глубину (DFS)");
+        Console.WriteLine(string.Join(" ", Vertex.VetsToVals(res)));
+    }
+}

ru/codes/csharp/chapter_greedy/coin_change_greedy.cs

@@ -0,0 +1,54 @@
+/**
+* File: coin_change_greedy.cs
+* Created Time: 2023-07-21
+* Author: hpstory (hpstory1024@163.com)
+*/
+
+namespace hello_algo.chapter_greedy;
+
+public class coin_change_greedy {
+    /* Размен монет: жадный алгоритм */
+    int CoinChangeGreedy(int[] coins, int amt) {
+        // Предположить, что список coins упорядочен
+        int i = coins.Length - 1;
+        int count = 0;
+        // Циклически выполнять жадный выбор, пока не останется суммы
+        while (amt > 0) {
+            // Найти монету, которая меньше остатка суммы и наиболее к нему близка
+            while (i > 0 && coins[i] > amt) {
+                i--;
+            }
+            // Выбрать coins[i]
+            amt -= coins[i];
+            count++;
+        }
+        // Если допустимое решение не найдено, вернуть -1
+        return amt == 0 ? count : -1;
+    }
+
+    [Test]
+    public void Test() {
+        // Жадный подход: гарантирует нахождение глобально оптимального решения
+        int[] coins = [1, 5, 10, 20, 50, 100];
+        int amt = 186;
+        int res = CoinChangeGreedy(coins, amt);
+        Console.WriteLine("\ncoins = " + coins.PrintList() + ", amt = " + amt);
+        Console.WriteLine("Минимальное число монет для набора суммы " + amt + " = " + res);
+
+        // Жадный подход: не гарантирует нахождение глобально оптимального решения
+        coins = [1, 20, 50];
+        amt = 60;
+        res = CoinChangeGreedy(coins, amt);
+        Console.WriteLine("\ncoins = " + coins.PrintList() + ", amt = " + amt);
+        Console.WriteLine("Минимальное число монет для набора суммы " + amt + " = " + res);
+        Console.WriteLine("На самом деле минимум равен 3: 20 + 20 + 20");
+
+        // Жадный подход: не гарантирует нахождение глобально оптимального решения
+        coins = [1, 49, 50];
+        amt = 98;
+        res = CoinChangeGreedy(coins, amt);
+        Console.WriteLine("\ncoins = " + coins.PrintList() + ", amt = " + amt);
+        Console.WriteLine("Минимальное число монет для набора суммы " + amt + " = " + res);
+        Console.WriteLine("На самом деле минимум равен 2: 49 + 49");
+    }
+}

ru/codes/csharp/chapter_greedy/fractional_knapsack.cs

@@ -0,0 +1,52 @@
+/**
+* File: fractional_knapsack.cs
+* Created Time: 2023-07-21
+* Author: hpstory (hpstory1024@163.com)
+*/
+
+namespace hello_algo.chapter_greedy;
+
+/* Предмет */
+class Item(int w, int v) {
+    public int w = w; // Вес предмета
+    public int v = v; // Стоимость предмета
+}
+
+public class fractional_knapsack {
+    /* Дробный рюкзак: жадный алгоритм */
+    double FractionalKnapsack(int[] wgt, int[] val, int cap) {
+        // Создать список предметов с двумя свойствами: вес и стоимость
+        Item[] items = new Item[wgt.Length];
+        for (int i = 0; i < wgt.Length; i++) {
+            items[i] = new Item(wgt[i], val[i]);
+        }
+        // Отсортировать по удельной стоимости item.v / item.w в порядке убывания
+        Array.Sort(items, (x, y) => (y.v / y.w).CompareTo(x.v / x.w));
+        // Циклический жадный выбор
+        double res = 0;
+        foreach (Item item in items) {
+            if (item.w <= cap) {
+                // Если оставшейся вместимости достаточно, положить в рюкзак текущий предмет целиком
+                res += item.v;
+                cap -= item.w;
+            } else {
+                // Если оставшейся вместимости недостаточно, положить в рюкзак часть текущего предмета
+                res += (double)item.v / item.w * cap;
+                // Свободной вместимости больше не осталось, поэтому выйти из цикла
+                break;
+            }
+        }
+        return res;
+    }
+
+    [Test]
+    public void Test() {
+        int[] wgt = [10, 20, 30, 40, 50];
+        int[] val = [50, 120, 150, 210, 240];
+        int cap = 50;
+
+        // Жадный алгоритм
+        double res = FractionalKnapsack(wgt, val, cap);
+        Console.WriteLine("Максимальная стоимость предметов без превышения вместимости рюкзака = " + res);
+    }
+}

ru/codes/csharp/chapter_greedy/max_capacity.cs

@@ -0,0 +1,39 @@
+/**
+* File: max_capacity.cs
+* Created Time: 2023-07-21
+* Author: hpstory (hpstory1024@163.com)
+*/
+
+namespace hello_algo.chapter_greedy;
+
+public class max_capacity {
+    /* Максимальная вместимость: жадный алгоритм */
+    int MaxCapacity(int[] ht) {
+        // Инициализировать i и j так, чтобы они располагались по двум концам массива
+        int i = 0, j = ht.Length - 1;
+        // Начальная максимальная вместимость равна 0
+        int res = 0;
+        // Выполнять жадный выбор в цикле, пока две доски не встретятся
+        while (i < j) {
+            // Обновить максимальную вместимость
+            int cap = Math.Min(ht[i], ht[j]) * (j - i);
+            res = Math.Max(res, cap);
+            // Сдвигать внутрь более короткую сторону
+            if (ht[i] < ht[j]) {
+                i++;
+            } else {
+                j--;
+            }
+        }
+        return res;
+    }
+
+    [Test]
+    public void Test() {
+        int[] ht = [3, 8, 5, 2, 7, 7, 3, 4];
+
+        // Жадный алгоритм
+        int res = MaxCapacity(ht);
+        Console.WriteLine("Максимальная вместимость = " + res);
+    }
+}

ru/codes/csharp/chapter_greedy/max_product_cutting.cs

@@ -0,0 +1,39 @@
+/**
+* File: max_product_cutting.cs
+* Created Time: 2023-07-21
+* Author: hpstory (hpstory1024@163.com)
+*/
+
+namespace hello_algo.chapter_greedy;
+
+public class max_product_cutting {
+    /* Максимальное произведение разрезания: жадный алгоритм */
+    int MaxProductCutting(int n) {
+        // Когда n <= 3, обязательно нужно выделить одну 1
+        if (n <= 3) {
+            return 1 * (n - 1);
+        }
+        // Жадно выделить множители 3, где a — число троек, а b — остаток
+        int a = n / 3;
+        int b = n % 3;
+        if (b == 1) {
+            // Если остаток равен 1, преобразовать одну пару 1 * 3 в 2 * 2
+            return (int)Math.Pow(3, a - 1) * 2 * 2;
+        }
+        if (b == 2) {
+            // Если остаток равен 2, ничего не делать
+            return (int)Math.Pow(3, a) * 2;
+        }
+        // Если остаток равен 0, ничего не делать
+        return (int)Math.Pow(3, a);
+    }
+
+    [Test]
+    public void Test() {
+        int n = 58;
+
+        // Жадный алгоритм
+        int res = MaxProductCutting(n);
+        Console.WriteLine("Максимальное произведение после разрезания = " + res);
+    }
+}

ru/codes/csharp/chapter_hashing/array_hash_map.cs

@@ -0,0 +1,134 @@
+/**
+ * File: array_hash_map.cs
+ * Created Time: 2022-12-23
+ * Author: haptear (haptear@hotmail.com)
+ */
+
+namespace hello_algo.chapter_hashing;
+
+/* Пара ключ-значение int->string */
+class Pair(int key, string val) {
+    public int key = key;
+    public string val = val;
+}
+
+/* Хеш-таблица на основе массива */
+class ArrayHashMap {
+    List<Pair?> buckets;
+    public ArrayHashMap() {
+        // Инициализировать массив, содержащий 100 корзин
+        buckets = [];
+        for (int i = 0; i < 100; i++) {
+            buckets.Add(null);
+        }
+    }
+
+    /* Хеш-функция */
+    int HashFunc(int key) {
+        int index = key % 100;
+        return index;
+    }
+
+    /* Операция поиска */
+    public string? Get(int key) {
+        int index = HashFunc(key);
+        Pair? pair = buckets[index];
+        if (pair == null) return null;
+        return pair.val;
+    }
+
+    /* Операция добавления */
+    public void Put(int key, string val) {
+        Pair pair = new(key, val);
+        int index = HashFunc(key);
+        buckets[index] = pair;
+    }
+
+    /* Операция удаления */
+    public void Remove(int key) {
+        int index = HashFunc(key);
+        // Присвоить null, что означает удаление
+        buckets[index] = null;
+    }
+
+    /* Получить все пары ключ-значение */
+    public List<Pair> PairSet() {
+        List<Pair> pairSet = [];
+        foreach (Pair? pair in buckets) {
+            if (pair != null)
+                pairSet.Add(pair);
+        }
+        return pairSet;
+    }
+
+    /* Получить все ключи */
+    public List<int> KeySet() {
+        List<int> keySet = [];
+        foreach (Pair? pair in buckets) {
+            if (pair != null)
+                keySet.Add(pair.key);
+        }
+        return keySet;
+    }
+
+    /* Получить все значения */
+    public List<string> ValueSet() {
+        List<string> valueSet = [];
+        foreach (Pair? pair in buckets) {
+            if (pair != null)
+                valueSet.Add(pair.val);
+        }
+        return valueSet;
+    }
+
+    /* Вывести хеш-таблицу */
+    public void Print() {
+        foreach (Pair kv in PairSet()) {
+            Console.WriteLine(kv.key + " -> " + kv.val);
+        }
+    }
+}
+
+
+public class array_hash_map {
+    [Test]
+    public void Test() {
+        /* Инициализация хеш-таблицы */
+        ArrayHashMap map = new();
+
+        /* Операция добавления */
+        // Добавить пару (key, value) в хеш-таблицу
+        map.Put(12836, "Сяо Ха");
+        map.Put(15937, "Сяо Ло");
+        map.Put(16750, "Сяо Суань");
+        map.Put(13276, "Сяо Фа");
+        map.Put(10583, "Сяо Я");
+        Console.WriteLine("\nПосле добавления хеш-таблица имеет вид\nКлюч -> Значение");
+        map.Print();
+
+        /* Операция поиска */
+        // Ввести в хеш-таблицу ключ key и получить значение value
+        string? name = map.Get(15937);
+        Console.WriteLine("\nДля номера 15937 найдено имя " + name);
+
+        /* Операция удаления */
+        // Удалить пару (key, value) из хеш-таблицы
+        map.Remove(10583);
+        Console.WriteLine("\nПосле удаления 10583 хеш-таблица имеет вид\nКлюч -> Значение");
+        map.Print();
+
+        /* Обход хеш-таблицы */
+        Console.WriteLine("\nОтдельный обход пар ключ-значение");
+        foreach (Pair kv in map.PairSet()) {
+            Console.WriteLine(kv.key + " -> " + kv.val);
+        }
+        Console.WriteLine("\nОтдельный обход ключей");
+        foreach (int key in map.KeySet()) {
+            Console.WriteLine(key);
+        }
+        Console.WriteLine("\nОтдельный обход значений");
+        foreach (string val in map.ValueSet()) {
+            Console.WriteLine(val);
+        }
+    }
+}

ru/codes/csharp/chapter_hashing/built_in_hash.cs

@@ -0,0 +1,36 @@
+/**
+* File: built_in_hash.cs
+* Created Time: 2023-06-26
+* Author: hpstory (hpstory1024@163.com)
+*/
+
+namespace hello_algo.chapter_hashing;
+
+public class built_in_hash {
+    [Test]
+    public void Test() {
+        int num = 3;
+        int hashNum = num.GetHashCode();
+        Console.WriteLine("Хеш-значение целого числа " + num + " = " + hashNum);
+
+        bool bol = true;
+        int hashBol = bol.GetHashCode();
+        Console.WriteLine("Хеш-значение булева значения " + bol + " = " + hashBol);
+
+        double dec = 3.14159;
+        int hashDec = dec.GetHashCode();
+        Console.WriteLine("Хеш-значение десятичного числа " + dec + " = " + hashDec);
+
+        string str = "Hello Algo";
+        int hashStr = str.GetHashCode();
+        Console.WriteLine("Хеш-значение строки " + str + " = " + hashStr);
+
+        object[] arr = [12836, "Сяо Ха"];
+        int hashTup = arr.GetHashCode();
+        Console.WriteLine("Хеш-значение массива [" + string.Join(", ", arr) + "] = " + hashTup);
+
+        ListNode obj = new(0);
+        int hashObj = obj.GetHashCode();
+        Console.WriteLine("Хеш-значение объекта узла " + obj + " = " + hashObj);
+    }
+}

ru/codes/csharp/chapter_hashing/hash_map.cs

@@ -0,0 +1,51 @@
+
+/**
+ * File: hash_map.cs
+ * Created Time: 2022-12-23
+ * Author: haptear (haptear@hotmail.com)
+ */
+
+namespace hello_algo.chapter_hashing;
+
+public class hash_map {
+    [Test]
+    public void Test() {
+        /* Инициализация хеш-таблицы */
+        Dictionary<int, string> map = new() {
+            /* Операция добавления */
+            // Добавить пару (key, value) в хеш-таблицу
+            { 12836, "Сяо Ха" },
+            { 15937, "Сяо Ло" },
+            { 16750, "Сяо Суань" },
+            { 13276, "Сяо Фа" },
+            { 10583, "Сяо Я" }
+        };
+        Console.WriteLine("\nПосле добавления хеш-таблица имеет вид\nКлюч -> Значение");
+        PrintUtil.PrintHashMap(map);
+
+        /* Операция поиска */
+        // Ввести в хеш-таблицу ключ key и получить значение value
+        string name = map[15937];
+        Console.WriteLine("\nДля номера 15937 найдено имя " + name);
+
+        /* Операция удаления */
+        // Удалить пару (key, value) из хеш-таблицы
+        map.Remove(10583);
+        Console.WriteLine("\nПосле удаления 10583 хеш-таблица имеет вид\nКлюч -> Значение");
+        PrintUtil.PrintHashMap(map);
+
+        /* Обход хеш-таблицы */
+        Console.WriteLine("\nОтдельный обход пар ключ-значение");
+        foreach (var kv in map) {
+            Console.WriteLine(kv.Key + " -> " + kv.Value);
+        }
+        Console.WriteLine("\nОтдельный обход ключей");
+        foreach (int key in map.Keys) {
+            Console.WriteLine(key);
+        }
+        Console.WriteLine("\nОтдельный обход значений");
+        foreach (string val in map.Values) {
+            Console.WriteLine(val);
+        }
+    }
+}

ru/codes/csharp/chapter_hashing/hash_map_chaining.cs

@@ -0,0 +1,144 @@
+/**
+* File: hash_map_chaining.cs
+* Created Time: 2023-06-26
+* Author: hpstory (hpstory1024@163.com)
+*/
+
+namespace hello_algo.chapter_hashing;
+
+/* Хеш-таблица с цепочками */
+class HashMapChaining {
+    int size; // Число пар ключ-значение
+    int capacity; // Вместимость хеш-таблицы
+    double loadThres; // Порог коэффициента загрузки для запуска расширения
+    int extendRatio; // Коэффициент расширения
+    List<List<Pair>> buckets; // Массив корзин
+
+    /* Конструктор */
+    public HashMapChaining() {
+        size = 0;
+        capacity = 4;
+        loadThres = 2.0 / 3.0;
+        extendRatio = 2;
+        buckets = new List<List<Pair>>(capacity);
+        for (int i = 0; i < capacity; i++) {
+            buckets.Add([]);
+        }
+    }
+
+    /* Хеш-функция */
+    int HashFunc(int key) {
+        return key % capacity;
+    }
+
+    /* Коэффициент загрузки */
+    double LoadFactor() {
+        return (double)size / capacity;
+    }
+
+    /* Операция поиска */
+    public string? Get(int key) {
+        int index = HashFunc(key);
+        // Обойти корзину; если найден key, вернуть соответствующее val
+        foreach (Pair pair in buckets[index]) {
+            if (pair.key == key) {
+                return pair.val;
+            }
+        }
+        // Если key не найден, вернуть null
+        return null;
+    }
+
+    /* Операция добавления */
+    public void Put(int key, string val) {
+        // Когда коэффициент загрузки превышает порог, выполнить расширение
+        if (LoadFactor() > loadThres) {
+            Extend();
+        }
+        int index = HashFunc(key);
+        // Обойти корзину; если встретился указанный key, обновить соответствующее val и вернуть
+        foreach (Pair pair in buckets[index]) {
+            if (pair.key == key) {
+                pair.val = val;
+                return;
+            }
+        }
+        // Если такого key нет, добавить пару ключ-значение в конец
+        buckets[index].Add(new Pair(key, val));
+        size++;
+    }
+
+    /* Операция удаления */
+    public void Remove(int key) {
+        int index = HashFunc(key);
+        // Обойти корзину и удалить из нее пару ключ-значение
+        foreach (Pair pair in buckets[index].ToList()) {
+            if (pair.key == key) {
+                buckets[index].Remove(pair);
+                size--;
+                break;
+            }
+        }
+    }
+
+    /* Расширить хеш-таблицу */
+    void Extend() {
+        // Временно сохранить исходную хеш-таблицу
+        List<List<Pair>> bucketsTmp = buckets;
+        // Инициализация новой хеш-таблицы после расширения
+        capacity *= extendRatio;
+        buckets = new List<List<Pair>>(capacity);
+        for (int i = 0; i < capacity; i++) {
+            buckets.Add([]);
+        }
+        size = 0;
+        // Перенести пары ключ-значение из исходной хеш-таблицы в новую
+        foreach (List<Pair> bucket in bucketsTmp) {
+            foreach (Pair pair in bucket) {
+                Put(pair.key, pair.val);
+            }
+        }
+    }
+
+    /* Вывести хеш-таблицу */
+    public void Print() {
+        foreach (List<Pair> bucket in buckets) {
+            List<string> res = [];
+            foreach (Pair pair in bucket) {
+                res.Add(pair.key + " -> " + pair.val);
+            }
+            foreach (string kv in res) {
+                Console.WriteLine(kv);
+            }
+        }
+    }
+}
+
+public class hash_map_chaining {
+    [Test]
+    public void Test() {
+        /* Инициализация хеш-таблицы */
+        HashMapChaining map = new();
+
+        /* Операция добавления */
+        // Добавить пару (key, value) в хеш-таблицу
+        map.Put(12836, "Сяо Ха");
+        map.Put(15937, "Сяо Ло");
+        map.Put(16750, "Сяо Суань");
+        map.Put(13276, "Сяо Фа");
+        map.Put(10583, "Сяо Я");
+        Console.WriteLine("\nПосле добавления хеш-таблица имеет вид\nКлюч -> Значение");
+        map.Print();
+
+        /* Операция поиска */
+        // Ввести в хеш-таблицу ключ key и получить значение value
+        string? name = map.Get(13276);
+        Console.WriteLine("\nДля номера 13276 найдено имя " + name);
+
+        /* Операция удаления */
+        // Удалить пару (key, value) из хеш-таблицы
+        map.Remove(12836);
+        Console.WriteLine("\nПосле удаления 12836 хеш-таблица имеет вид\nКлюч -> Значение");
+        map.Print();
+    }
+}

ru/codes/csharp/chapter_hashing/hash_map_open_addressing.cs

@@ -0,0 +1,159 @@
+/**
+* File: hash_map_open_addressing.cs
+* Created Time: 2023-06-26
+* Author: hpstory (hpstory1024@163.com)
+*/
+
+namespace hello_algo.chapter_hashing;
+
+/* Хеш-таблица с открытой адресацией */
+class HashMapOpenAddressing {
+    int size; // Число пар ключ-значение
+    int capacity = 4; // Вместимость хеш-таблицы
+    double loadThres = 2.0 / 3.0; // Порог коэффициента загрузки для запуска расширения
+    int extendRatio = 2; // Коэффициент расширения
+    Pair[] buckets; // Массив корзин
+    Pair TOMBSTONE = new(-1, "-1"); // Удалить метку
+
+    /* Конструктор */
+    public HashMapOpenAddressing() {
+        size = 0;
+        buckets = new Pair[capacity];
+    }
+
+    /* Хеш-функция */
+    int HashFunc(int key) {
+        return key % capacity;
+    }
+
+    /* Коэффициент загрузки */
+    double LoadFactor() {
+        return (double)size / capacity;
+    }
+
+    /* Найти индекс корзины, соответствующий key */
+    int FindBucket(int key) {
+        int index = HashFunc(key);
+        int firstTombstone = -1;
+        // Выполнять линейное пробирование и завершить при встрече с пустой корзиной
+        while (buckets[index] != null) {
+            // Если встретился key, вернуть соответствующий индекс корзины
+            if (buckets[index].key == key) {
+                // Если ранее встретилась метка удаления, переместить пару ключ-значение на этот индекс
+                if (firstTombstone != -1) {
+                    buckets[firstTombstone] = buckets[index];
+                    buckets[index] = TOMBSTONE;
+                    return firstTombstone; // Вернуть индекс корзины после перемещения
+                }
+                return index; // Вернуть индекс корзины
+            }
+            // Записать первую встретившуюся метку удаления
+            if (firstTombstone == -1 && buckets[index] == TOMBSTONE) {
+                firstTombstone = index;
+            }
+            // Вычислить индекс корзины; при выходе за конец вернуться к началу
+            index = (index + 1) % capacity;
+        }
+        // Если key не существует, вернуть индекс точки добавления
+        return firstTombstone == -1 ? index : firstTombstone;
+    }
+
+    /* Операция поиска */
+    public string? Get(int key) {
+        // Найти индекс корзины, соответствующий key
+        int index = FindBucket(key);
+        // Если пара ключ-значение найдена, вернуть соответствующее val
+        if (buckets[index] != null && buckets[index] != TOMBSTONE) {
+            return buckets[index].val;
+        }
+        // Если пары ключ-значение не существует, вернуть null
+        return null;
+    }
+
+    /* Операция добавления */
+    public void Put(int key, string val) {
+        // Когда коэффициент загрузки превышает порог, выполнить расширение
+        if (LoadFactor() > loadThres) {
+            Extend();
+        }
+        // Найти индекс корзины, соответствующий key
+        int index = FindBucket(key);
+        // Если пара ключ-значение найдена, перезаписать val и вернуть
+        if (buckets[index] != null && buckets[index] != TOMBSTONE) {
+            buckets[index].val = val;
+            return;
+        }
+        // Если пары ключ-значение нет, добавить ее
+        buckets[index] = new Pair(key, val);
+        size++;
+    }
+
+    /* Операция удаления */
+    public void Remove(int key) {
+        // Найти индекс корзины, соответствующий key
+        int index = FindBucket(key);
+        // Если пара ключ-значение найдена, заменить ее меткой удаления
+        if (buckets[index] != null && buckets[index] != TOMBSTONE) {
+            buckets[index] = TOMBSTONE;
+            size--;
+        }
+    }
+
+    /* Расширить хеш-таблицу */
+    void Extend() {
+        // Временно сохранить исходную хеш-таблицу
+        Pair[] bucketsTmp = buckets;
+        // Инициализация новой хеш-таблицы после расширения
+        capacity *= extendRatio;
+        buckets = new Pair[capacity];
+        size = 0;
+        // Перенести пары ключ-значение из исходной хеш-таблицы в новую
+        foreach (Pair pair in bucketsTmp) {
+            if (pair != null && pair != TOMBSTONE) {
+                Put(pair.key, pair.val);
+            }
+        }
+    }
+
+    /* Вывести хеш-таблицу */
+    public void Print() {
+        foreach (Pair pair in buckets) {
+            if (pair == null) {
+                Console.WriteLine("null");
+            } else if (pair == TOMBSTONE) {
+                Console.WriteLine("TOMBSTONE");
+            } else {
+                Console.WriteLine(pair.key + " -> " + pair.val);
+            }
+        }
+    }
+}
+
+public class hash_map_open_addressing {
+    [Test]
+    public void Test() {
+        /* Инициализация хеш-таблицы */
+        HashMapOpenAddressing map = new();
+
+        /* Операция добавления */
+        // Добавить пару (key, value) в хеш-таблицу
+        map.Put(12836, "Сяо Ха");
+        map.Put(15937, "Сяо Ло");
+        map.Put(16750, "Сяо Суань");
+        map.Put(13276, "Сяо Фа");
+        map.Put(10583, "Сяо Я");
+        Console.WriteLine("\nПосле добавления хеш-таблица имеет вид\nКлюч -> Значение");
+        map.Print();
+
+        /* Операция поиска */
+        // Ввести в хеш-таблицу ключ key и получить значение value
+        string? name = map.Get(13276);
+        Console.WriteLine("\nДля номера 13276 найдено имя " + name);
+
+        /* Операция удаления */
+        // Удалить пару (key, value) из хеш-таблицы
+        map.Remove(16750);
+        Console.WriteLine("\nПосле удаления 16750 хеш-таблица имеет вид\nКлюч -> Значение");
+        map.Print();
+    }
+}

ru/codes/csharp/chapter_hashing/simple_hash.cs

@@ -0,0 +1,66 @@
+/**
+* File: simple_hash.cs
+* Created Time: 2023-06-26
+* Author: hpstory (hpstory1024@163.com)
+*/
+
+namespace hello_algo.chapter_hashing;
+
+public class simple_hash {
+    /* Аддитивное хеширование */
+    int AddHash(string key) {
+        long hash = 0;
+        const int MODULUS = 1000000007;
+        foreach (char c in key) {
+            hash = (hash + c) % MODULUS;
+        }
+        return (int)hash;
+    }
+
+    /* Мультипликативное хеширование */
+    int MulHash(string key) {
+        long hash = 0;
+        const int MODULUS = 1000000007;
+        foreach (char c in key) {
+            hash = (31 * hash + c) % MODULUS;
+        }
+        return (int)hash;
+    }
+
+    /* XOR-хеширование */
+    int XorHash(string key) {
+        int hash = 0;
+        const int MODULUS = 1000000007;
+        foreach (char c in key) {
+            hash ^= c;
+        }
+        return hash & MODULUS;
+    }
+
+    /* Хеширование с циклическим сдвигом */
+    int RotHash(string key) {
+        long hash = 0;
+        const int MODULUS = 1000000007;
+        foreach (char c in key) {
+            hash = ((hash << 4) ^ (hash >> 28) ^ c) % MODULUS;
+        }
+        return (int)hash;
+    }
+
+    [Test]
+    public void Test() {
+        string key = "Hello Algo";
+
+        int hash = AddHash(key);
+        Console.WriteLine("Хеш-сумма сложением = " + hash);
+
+        hash = MulHash(key);
+        Console.WriteLine("Хеш-сумма умножением = " + hash);
+
+        hash = XorHash(key);
+        Console.WriteLine("Хеш-сумма XOR = " + hash);
+
+        hash = RotHash(key);
+        Console.WriteLine("Хеш-сумма с циклическим сдвигом = " + hash);
+    }
+}

ru/codes/csharp/chapter_heap/heap.cs

@@ -0,0 +1,64 @@
+/**
+ * File: heap.cs
+ * Created Time: 2023-02-06
+ * Author: zjkung1123 (zjkung1123@gmail.com)
+ */
+
+namespace hello_algo.chapter_heap;
+
+public class heap {
+    void TestPush(PriorityQueue<int, int> heap, int val) {
+        heap.Enqueue(val, val); // Добавление элемента в кучу
+        Console.WriteLine($"\nПосле добавления элемента {val} в кучу\n");
+        PrintUtil.PrintHeap(heap);
+    }
+
+    void TestPop(PriorityQueue<int, int> heap) {
+        int val = heap.Dequeue(); // Извлечение элемента с вершины кучи
+        Console.WriteLine($"\nПосле извлечения элемента вершины кучи {val}\n");
+        PrintUtil.PrintHeap(heap);
+    }
+
+    [Test]
+    public void Test() {
+        /* Инициализация кучи */
+        // Инициализация минимальной кучи
+        PriorityQueue<int, int> minHeap = new();
+        // Инициализировать максимальную кучу (достаточно изменить Comparer с помощью lambda-выражения)
+        PriorityQueue<int, int> maxHeap = new(Comparer<int>.Create((x, y) => y.CompareTo(x)));
+        Console.WriteLine("Ниже приведен тестовый пример для max-heap");
+
+        /* Добавление элемента в кучу */
+        TestPush(maxHeap, 1);
+        TestPush(maxHeap, 3);
+        TestPush(maxHeap, 2);
+        TestPush(maxHeap, 5);
+        TestPush(maxHeap, 4);
+
+        /* Получение элемента с вершины кучи */
+        int peek = maxHeap.Peek();
+        Console.WriteLine($"Элемент на вершине кучи = {peek}");
+
+        /* Извлечение элемента с вершины кучи */
+        // Элементы, извлеченные из кучи, образуют последовательность от большего к меньшему
+        TestPop(maxHeap);
+        TestPop(maxHeap);
+        TestPop(maxHeap);
+        TestPop(maxHeap);
+        TestPop(maxHeap);
+
+        /* Получение размера кучи */
+        int size = maxHeap.Count;
+        Console.WriteLine($"Количество элементов в куче = {size}");
+
+        /* Проверка, пуста ли куча */
+        bool isEmpty = maxHeap.Count == 0;
+        Console.WriteLine($"Пуста ли куча: {isEmpty}");
+
+        /* Построить кучу по входному списку */
+        var list = new int[] { 1, 3, 2, 5, 4 };
+        minHeap = new PriorityQueue<int, int>(list.Select(x => (x, x)));
+        Console.WriteLine("После построения min-heap из входного списка");
+        PrintUtil.PrintHeap(minHeap);
+    }
+}

ru/codes/csharp/chapter_heap/my_heap.cs

@@ -0,0 +1,160 @@
+/**
+ * File: my_heap.cs
+ * Created Time: 2023-02-06
+ * Author: zjkung1123 (zjkung1123@gmail.com)
+ */
+
+namespace hello_algo.chapter_heap;
+
+/* Максимальная куча */
+class MaxHeap {
+    // Использовать список вместо массива, чтобы не учитывать проблему расширения
+    List<int> maxHeap;
+
+    /* Конструктор, создающий пустую кучу */
+    public MaxHeap() {
+        maxHeap = [];
+    }
+
+    /* Конструктор: построить кучу по входному списку */
+    public MaxHeap(IEnumerable<int> nums) {
+        // Добавить элементы списка в кучу без изменений
+        maxHeap = new List<int>(nums);
+        // Выполнить heapify для всех узлов, кроме листовых
+        var size = Parent(this.Size() - 1);
+        for (int i = size; i >= 0; i--) {
+            SiftDown(i);
+        }
+    }
+
+    /* Получить индекс левого дочернего узла */
+    int Left(int i) {
+        return 2 * i + 1;
+    }
+
+    /* Получить индекс правого дочернего узла */
+    int Right(int i) {
+        return 2 * i + 2;
+    }
+
+    /* Получить индекс родительского узла */
+    int Parent(int i) {
+        return (i - 1) / 2; // Округление вниз при делении
+    }
+
+    /* Доступ к элементу на вершине кучи */
+    public int Peek() {
+        return maxHeap[0];
+    }
+
+    /* Добавление элемента в кучу */
+    public void Push(int val) {
+        // Добавление узла
+        maxHeap.Add(val);
+        // Просеивание снизу вверх
+        SiftUp(Size() - 1);
+    }
+
+    /* Получение размера кучи */
+    public int Size() {
+        return maxHeap.Count;
+    }
+
+    /* Проверка, пуста ли куча */
+    public bool IsEmpty() {
+        return Size() == 0;
+    }
+
+    /* Начиная с узла i, выполнить просеивание снизу вверх */
+    void SiftUp(int i) {
+        while (true) {
+            // Получение родительского узла для узла i
+            int p = Parent(i);
+            // Если «выход за пределы корневого узла» или «узел не требует исправления», завершить просеивание
+            if (p < 0 || maxHeap[i] <= maxHeap[p])
+                break;
+            // Поменять два узла местами
+            Swap(i, p);
+            // Циклическое просеивание вверх
+            i = p;
+        }
+    }
+
+    /* Извлечение элемента из кучи */
+    public int Pop() {
+        // Обработка пустого случая
+        if (IsEmpty())
+            throw new IndexOutOfRangeException();
+        // Поменять корневой узел с самым правым листом местами (поменять первый и последний элементы)
+        Swap(0, Size() - 1);
+        // Удаление узла
+        int val = maxHeap.Last();
+        maxHeap.RemoveAt(Size() - 1);
+        // Просеивание сверху вниз
+        SiftDown(0);
+        // Вернуть элемент с вершины кучи
+        return val;
+    }
+
+    /* Начиная с узла i, выполнить просеивание сверху вниз */
+    void SiftDown(int i) {
+        while (true) {
+            // Определить узел с максимальным значением среди i, l и r и обозначить его как ma
+            int l = Left(i), r = Right(i), ma = i;
+            if (l < Size() && maxHeap[l] > maxHeap[ma])
+                ma = l;
+            if (r < Size() && maxHeap[r] > maxHeap[ma])
+                ma = r;
+            // Если «узел i максимален» или «выход за пределы листовых узлов», завершить просеивание
+            if (ma == i) break;
+            // Поменять два узла местами
+            Swap(i, ma);
+            // Циклическое просеивание вниз
+            i = ma;
+        }
+    }
+
+    /* Поменять элементы местами */
+    void Swap(int i, int p) {
+        (maxHeap[i], maxHeap[p]) = (maxHeap[p], maxHeap[i]);
+    }
+
+    /* Вывести кучу (двоичное дерево) */
+    public void Print() {
+        var queue = new Queue<int>(maxHeap);
+        PrintUtil.PrintHeap(queue);
+    }
+}
+
+public class my_heap {
+    [Test]
+    public void Test() {
+        /* Инициализация максимальной кучи */
+        MaxHeap maxHeap = new([9, 8, 6, 6, 7, 5, 2, 1, 4, 3, 6, 2]);
+        Console.WriteLine("\nПосле построения кучи из входного списка");
+        maxHeap.Print();
+
+        /* Получение элемента с вершины кучи */
+        int peek = maxHeap.Peek();
+        Console.WriteLine($"Элемент на вершине кучи = {peek}");
+
+        /* Добавление элемента в кучу */
+        int val = 7;
+        maxHeap.Push(val);
+        Console.WriteLine($"После добавления элемента {val} в кучу");
+        maxHeap.Print();
+
+        /* Извлечение элемента с вершины кучи */
+        peek = maxHeap.Pop();
+        Console.WriteLine($"После извлечения элемента вершины кучи {peek}");
+        maxHeap.Print();
+
+        /* Получение размера кучи */
+        int size = maxHeap.Size();
+        Console.WriteLine($"Количество элементов в куче = {size}");
+
+        /* Проверка, пуста ли куча */
+        bool isEmpty = maxHeap.IsEmpty();
+        Console.WriteLine($"Пуста ли куча: {isEmpty}");
+    }
+}

ru/codes/csharp/chapter_heap/top_k.cs

@@ -0,0 +1,37 @@
+/**
+* File: top_k.cs
+* Created Time: 2023-06-14
+* Author: hpstory (hpstory1024@163.com)
+*/
+
+namespace hello_algo.chapter_heap;
+
+public class top_k {
+    /* Найти k наибольших элементов массива с помощью кучи */
+    PriorityQueue<int, int> TopKHeap(int[] nums, int k) {
+        // Инициализация минимальной кучи
+        PriorityQueue<int, int> heap = new();
+        // Поместить первые k элементов массива в кучу
+        for (int i = 0; i < k; i++) {
+            heap.Enqueue(nums[i], nums[i]);
+        }
+        // Начиная с элемента k+1, поддерживать длину кучи равной k
+        for (int i = k; i < nums.Length; i++) {
+            // Если текущий элемент больше элемента на вершине кучи, извлечь вершину кучи и добавить текущий элемент в кучу
+            if (nums[i] > heap.Peek()) {
+                heap.Dequeue();
+                heap.Enqueue(nums[i], nums[i]);
+            }
+        }
+        return heap;
+    }
+
+    [Test]
+    public void Test() {
+        int[] nums = [1, 7, 6, 3, 2];
+        int k = 3;
+        PriorityQueue<int, int> res = TopKHeap(nums, k);
+        Console.WriteLine("Наибольшие " + k + " элементов =");
+        PrintUtil.PrintHeap(res);
+    }
+}

ru/codes/csharp/chapter_searching/binary_search.cs

@@ -0,0 +1,59 @@
+/**
+ * File: binary_search.cs
+ * Created Time: 2022-12-23
+ * Author: haptear (haptear@hotmail.com)
+ */
+
+namespace hello_algo.chapter_searching;
+
+public class binary_search {
+    /* Бинарный поиск (двусторонне замкнутый интервал) */
+    int BinarySearch(int[] nums, int target) {
+        // Инициализировать двусторонне замкнутый интервал [0, n-1], то есть i и j указывают на первый и последний элементы массива соответственно
+        int i = 0, j = nums.Length - 1;
+        // Цикл завершается, когда диапазон поиска пуст (при i > j диапазон пуст)
+        while (i <= j) {
+            int m = i + (j - i) / 2;   // Вычислить индекс середины m
+            if (nums[m] < target)      // Это означает, что target находится в интервале [m+1, j]
+                i = m + 1;
+            else if (nums[m] > target) // Это означает, что target находится в интервале [i, m-1]
+                j = m - 1;
+            else                       // Целевой элемент найден, вернуть его индекс
+                return m;
+        }
+        // Целевой элемент не найден, вернуть -1
+        return -1;
+    }
+
+    /* Бинарный поиск (лево замкнутый, право открытый интервал) */
+    int BinarySearchLCRO(int[] nums, int target) {
+        // Инициализировать лево замкнутый, право открытый интервал [0, n), то есть i и j указывают на первый элемент массива и позицию сразу за последним элементом соответственно
+        int i = 0, j = nums.Length;
+        // Цикл завершается, когда диапазон поиска пуст (при i = j диапазон пуст)
+        while (i < j) {
+            int m = i + (j - i) / 2;   // Вычислить индекс середины m
+            if (nums[m] < target)      // Это означает, что target находится в интервале [m+1, j)
+                i = m + 1;
+            else if (nums[m] > target) // Это означает, что target находится в интервале [i, m)
+                j = m;
+            else                       // Целевой элемент найден, вернуть его индекс
+                return m;
+        }
+        // Целевой элемент не найден, вернуть -1
+        return -1;
+    }
+
+    [Test]
+    public void Test() {
+        int target = 6;
+        int[] nums = [1, 3, 6, 8, 12, 15, 23, 26, 31, 35];
+
+        /* Бинарный поиск (двусторонне замкнутый интервал) */
+        int index = BinarySearch(nums, target);
+        Console.WriteLine("Индекс целевого элемента 6 = " + index);
+
+        /* Бинарный поиск (лево замкнутый, право открытый интервал) */
+        index = BinarySearchLCRO(nums, target);
+        Console.WriteLine("Индекс целевого элемента 6 = " + index);
+    }
+}

ru/codes/csharp/chapter_searching/binary_search_edge.cs

@@ -0,0 +1,50 @@
+/**
+* File: binary_search_edge.cs
+* Created Time: 2023-08-06
+* Author: hpstory (hpstory1024@163.com)
+*/
+
+namespace hello_algo.chapter_searching;
+
+public class binary_search_edge {
+    /* Бинарный поиск самого левого target */
+    int BinarySearchLeftEdge(int[] nums, int target) {
+        // Эквивалентно поиску точки вставки target
+        int i = binary_search_insertion.BinarySearchInsertion(nums, target);
+        // target не найден, вернуть -1
+        if (i == nums.Length || nums[i] != target) {
+            return -1;
+        }
+        // Найти target и вернуть индекс i
+        return i;
+    }
+
+    /* Бинарный поиск самого правого target */
+    int BinarySearchRightEdge(int[] nums, int target) {
+        // Преобразовать задачу в поиск самого левого target + 1
+        int i = binary_search_insertion.BinarySearchInsertion(nums, target + 1);
+        // j указывает на самый правый target, а i — на первый элемент больше target
+        int j = i - 1;
+        // target не найден, вернуть -1
+        if (j == -1 || nums[j] != target) {
+            return -1;
+        }
+        // Найти target и вернуть индекс j
+        return j;
+    }
+
+    [Test]
+    public void Test() {
+        // Массив с повторяющимися элементами
+        int[] nums = [1, 3, 6, 6, 6, 6, 6, 10, 12, 15];
+        Console.WriteLine("\nМассив nums = " + nums.PrintList());
+
+        // Бинарный поиск левой и правой границы
+        foreach (int target in new int[] { 6, 7 }) {
+            int index = BinarySearchLeftEdge(nums, target);
+            Console.WriteLine("Индекс самого левого элемента " + target + " равен " + index);
+            index = BinarySearchRightEdge(nums, target);
+            Console.WriteLine("Индекс самого правого элемента " + target + " равен " + index);
+        }
+    }
+}

ru/codes/csharp/chapter_searching/binary_search_insertion.cs

@@ -0,0 +1,64 @@
+/**
+* File: binary_search_insertion.cs
+* Created Time: 2023-08-06
+* Author: hpstory (hpstory1024@163.com)
+*/
+
+namespace hello_algo.chapter_searching;
+
+public class binary_search_insertion {
+    /* Бинарный поиск точки вставки (без повторяющихся элементов) */
+    public static int BinarySearchInsertionSimple(int[] nums, int target) {
+        int i = 0, j = nums.Length - 1; // Инициализировать двусторонне замкнутый интервал [0, n-1]
+        while (i <= j) {
+            int m = i + (j - i) / 2; // Вычислить индекс середины m
+            if (nums[m] < target) {
+                i = m + 1; // target находится в интервале [m+1, j]
+            } else if (nums[m] > target) {
+                j = m - 1; // target находится в интервале [i, m-1]
+            } else {
+                return m; // Найти target и вернуть точку вставки m
+            }
+        }
+        // target не найден, вернуть точку вставки i
+        return i;
+    }
+
+    /* Бинарный поиск точки вставки (с повторяющимися элементами) */
+    public static int BinarySearchInsertion(int[] nums, int target) {
+        int i = 0, j = nums.Length - 1; // Инициализировать двусторонне замкнутый интервал [0, n-1]
+        while (i <= j) {
+            int m = i + (j - i) / 2; // Вычислить индекс середины m
+            if (nums[m] < target) {
+                i = m + 1; // target находится в интервале [m+1, j]
+            } else if (nums[m] > target) {
+                j = m - 1; // target находится в интервале [i, m-1]
+            } else {
+                j = m - 1; // Первый элемент меньше target находится в интервале [i, m-1]
+            }
+        }
+        // Вернуть точку вставки i
+        return i;
+    }
+
+    [Test]
+    public void Test() {
+        // Массив без повторяющихся элементов
+        int[] nums = [1, 3, 6, 8, 12, 15, 23, 26, 31, 35];
+        Console.WriteLine("\nМассив nums = " + nums.PrintList());
+        // Бинарный поиск точки вставки
+        foreach (int target in new int[] { 6, 9 }) {
+            int index = BinarySearchInsertionSimple(nums, target);
+            Console.WriteLine("Индекс позиции вставки элемента " + target + " равен " + index);
+        }
+
+        // Массив с повторяющимися элементами
+        nums = [1, 3, 6, 6, 6, 6, 6, 10, 12, 15];
+        Console.WriteLine("\nМассив nums = " + nums.PrintList());
+        // Бинарный поиск точки вставки
+        foreach (int target in new int[] { 2, 6, 20 }) {
+            int index = BinarySearchInsertion(nums, target);
+            Console.WriteLine("Индекс позиции вставки элемента " + target + " равен " + index);
+        }
+    }
+}

ru/codes/csharp/chapter_searching/hashing_search.cs

@@ -0,0 +1,50 @@
+/**
+ * File: hashing_search.cs
+ * Created Time: 2022-12-23
+ * Author: haptear (haptear@hotmail.com)
+ */
+
+namespace hello_algo.chapter_searching;
+
+public class hashing_search {
+    /* Хеш-поиск (массив) */
+    int HashingSearchArray(Dictionary<int, int> map, int target) {
+        // key хеш-таблицы: целевой элемент, value: индекс
+        // Если такого key нет в хеш-таблице, вернуть -1
+        return map.GetValueOrDefault(target, -1);
+    }
+
+    /* Хеш-поиск (связный список) */
+    ListNode? HashingSearchLinkedList(Dictionary<int, ListNode> map, int target) {
+
+        // key хеш-таблицы: значение целевого узла, value: объект узла
+        // Если такого key нет в хеш-таблице, вернуть null
+        return map.GetValueOrDefault(target);
+    }
+
+    [Test]
+    public void Test() {
+        int target = 3;
+
+        /* Хеш-поиск (массив) */
+        int[] nums = [1, 5, 3, 2, 4, 7, 5, 9, 10, 8];
+        // Инициализация хеш-таблицы
+        Dictionary<int, int> map = [];
+        for (int i = 0; i < nums.Length; i++) {
+            map[nums[i]] = i;  // key: элемент, value: индекс
+        }
+        int index = HashingSearchArray(map, target);
+        Console.WriteLine("Индекс целевого элемента 3 = " + index);
+
+        /* Хеш-поиск (связный список) */
+        ListNode? head = ListNode.ArrToLinkedList(nums);
+        // Инициализация хеш-таблицы
+        Dictionary<int, ListNode> map1 = [];
+        while (head != null) {
+            map1[head.val] = head;  // key: значение узла, value: узел
+            head = head.next;
+        }
+        ListNode? node = HashingSearchLinkedList(map1, target);
+        Console.WriteLine("Объект узла со значением 3 = " + node);
+    }
+}

ru/codes/csharp/chapter_searching/linear_search.cs

@@ -0,0 +1,49 @@
+/**
+ * File: linear_search.cs
+ * Created Time: 2022-12-23
+ * Author: haptear (haptear@hotmail.com)
+ */
+
+namespace hello_algo.chapter_searching;
+
+public class linear_search {
+    /* Линейный поиск (массив) */
+    int LinearSearchArray(int[] nums, int target) {
+        // Обход массива
+        for (int i = 0; i < nums.Length; i++) {
+            // Целевой элемент найден, вернуть его индекс
+            if (nums[i] == target)
+                return i;
+        }
+        // Целевой элемент не найден, вернуть -1
+        return -1;
+    }
+
+    /* Линейный поиск (связный список) */
+    ListNode? LinearSearchLinkedList(ListNode? head, int target) {
+        // Обойти связный список
+        while (head != null) {
+            // Найти целевой узел и вернуть его
+            if (head.val == target)
+                return head;
+            head = head.next;
+        }
+        // Целевой узел не найден, вернуть null
+        return null;
+    }
+
+    [Test]
+    public void Test() {
+        int target = 3;
+
+        /* Выполнить линейный поиск в массиве */
+        int[] nums = [1, 5, 3, 2, 4, 7, 5, 9, 10, 8];
+        int index = LinearSearchArray(nums, target);
+        Console.WriteLine("Индекс целевого элемента 3 = " + index);
+
+        /* Выполнить линейный поиск в связном списке */
+        ListNode? head = ListNode.ArrToLinkedList(nums);
+        ListNode? node = LinearSearchLinkedList(head, target);
+        Console.WriteLine("Объект узла со значением 3 = " + node);
+    }
+}

ru/codes/csharp/chapter_searching/two_sum.cs

@@ -0,0 +1,52 @@
+/**
+ * File: two_sum.cs
+ * Created Time: 2022-12-23
+ * Author: haptear (haptear@hotmail.com)
+ */
+
+namespace hello_algo.chapter_searching;
+
+public class two_sum {
+    /* Метод 1: полный перебор */
+    int[] TwoSumBruteForce(int[] nums, int target) {
+        int size = nums.Length;
+        // Два вложенных цикла, временная сложность O(n^2)
+        for (int i = 0; i < size - 1; i++) {
+            for (int j = i + 1; j < size; j++) {
+                if (nums[i] + nums[j] == target)
+                    return [i, j];
+            }
+        }
+        return [];
+    }
+
+    /* Метод 2: вспомогательная хеш-таблица */
+    int[] TwoSumHashTable(int[] nums, int target) {
+        int size = nums.Length;
+        // Вспомогательная хеш-таблица, пространственная сложность O(n)
+        Dictionary<int, int> dic = [];
+        // Один цикл, временная сложность O(n)
+        for (int i = 0; i < size; i++) {
+            if (dic.ContainsKey(target - nums[i])) {
+                return [dic[target - nums[i]], i];
+            }
+            dic.Add(nums[i], i);
+        }
+        return [];
+    }
+
+    [Test]
+    public void Test() {
+        // ======= Test Case =======
+        int[] nums = [2, 7, 11, 15];
+        int target = 13;
+
+        // ====== Основной код ======
+        // Метод 1
+        int[] res = TwoSumBruteForce(nums, target);
+        Console.WriteLine("Результат метода 1 res = " + string.Join(",", res));
+        // Метод 2
+        res = TwoSumHashTable(nums, target);
+        Console.WriteLine("Результат метода 2 res = " + string.Join(",", res));
+    }
+}

ru/codes/csharp/chapter_sorting/bubble_sort.cs

@@ -0,0 +1,51 @@
+/**
+ * File: bubble_sort.cs
+ * Created Time: 2022-12-23
+ * Author: haptear (haptear@hotmail.com)
+ */
+
+namespace hello_algo.chapter_sorting;
+
+public class bubble_sort {
+    /* Пузырьковая сортировка */
+    void BubbleSort(int[] nums) {
+        // Внешний цикл: неотсортированный диапазон [0, i]
+        for (int i = nums.Length - 1; i > 0; i--) {
+            // Внутренний цикл: переместить максимальный элемент неотсортированного диапазона [0, i] в его правый конец
+            for (int j = 0; j < i; j++) {
+                if (nums[j] > nums[j + 1]) {
+                    // Поменять местами nums[j] и nums[j + 1]
+                    (nums[j + 1], nums[j]) = (nums[j], nums[j + 1]);
+                }
+            }
+        }
+    }
+
+    /* Пузырьковая сортировка (оптимизация флагом) */
+    void BubbleSortWithFlag(int[] nums) {
+        // Внешний цикл: неотсортированный диапазон [0, i]
+        for (int i = nums.Length - 1; i > 0; i--) {
+            bool flag = false; // Инициализировать флаг
+            // Внутренний цикл: переместить максимальный элемент неотсортированного диапазона [0, i] в его правый конец
+            for (int j = 0; j < i; j++) {
+                if (nums[j] > nums[j + 1]) {
+                    // Поменять местами nums[j] и nums[j + 1]
+                    (nums[j + 1], nums[j]) = (nums[j], nums[j + 1]);
+                    flag = true;  // Записать обмен элементов
+                }
+            }
+            if (!flag) break;     // На этой итерации «всплытия» не было ни одного обмена, сразу выйти
+        }
+    }
+
+    [Test]
+    public void Test() {
+        int[] nums = [4, 1, 3, 1, 5, 2];
+        BubbleSort(nums);
+        Console.WriteLine("После пузырьковой сортировки nums = " + string.Join(",", nums));
+
+        int[] nums1 = [4, 1, 3, 1, 5, 2];
+        BubbleSortWithFlag(nums1);
+        Console.WriteLine("После пузырьковой сортировки nums1 = " + string.Join(",", nums1));
+    }
+}

ru/codes/csharp/chapter_sorting/bucket_sort.cs

@@ -0,0 +1,46 @@
+/**
+ * File: bucket_sort.cs
+ * Created Time: 2023-04-13
+ * Author: hpstory (hpstory1024@163.com)
+ */
+
+namespace hello_algo.chapter_sorting;
+
+public class bucket_sort {
+    /* Сортировка корзинами */
+    void BucketSort(float[] nums) {
+        // Инициализировать k = n/2 корзин, предполагая распределение 2 элементов в каждую корзину
+        int k = nums.Length / 2;
+        List<List<float>> buckets = [];
+        for (int i = 0; i < k; i++) {
+            buckets.Add([]);
+        }
+        // 1. Распределить элементы массива по корзинам
+        foreach (float num in nums) {
+            // Входные данные лежат в диапазоне [0, 1); использовать num * k для отображения в диапазон индексов [0, k-1]
+            int i = (int)(num * k);
+            // Добавить num в корзину i
+            buckets[i].Add(num);
+        }
+        // 2. Выполнить сортировку внутри каждой корзины
+        foreach (List<float> bucket in buckets) {
+            // Использовать встроенную функцию сортировки; ее также можно заменить другим алгоритмом сортировки
+            bucket.Sort();
+        }
+        // 3. Обойти корзины и объединить результаты
+        int j = 0;
+        foreach (List<float> bucket in buckets) {
+            foreach (float num in bucket) {
+                nums[j++] = num;
+            }
+        }
+    }
+
+    [Test]
+    public void Test() {
+        // Пусть входные данные — числа с плавающей точкой из диапазона [0, 1)
+        float[] nums = [0.49f, 0.96f, 0.82f, 0.09f, 0.57f, 0.43f, 0.91f, 0.75f, 0.15f, 0.37f];
+        BucketSort(nums);
+        Console.WriteLine("После сортировки корзинами nums = " + string.Join(" ", nums));
+    }
+}

ru/codes/csharp/chapter_sorting/counting_sort.cs

@@ -0,0 +1,77 @@
+/**
+ * File: counting_sort.cs
+ * Created Time: 2023-04-13
+ * Author: hpstory (hpstory1024@163.com)
+ */
+
+namespace hello_algo.chapter_sorting;
+
+public class counting_sort {
+    /* Сортировка подсчетом */
+    // Простая реализация, не подходит для сортировки объектов
+    void CountingSortNaive(int[] nums) {
+        // 1. Найти максимальный элемент массива m
+        int m = 0;
+        foreach (int num in nums) {
+            m = Math.Max(m, num);
+        }
+        // 2. Подсчитать число появлений каждой цифры
+        // counter[num] обозначает число появлений num
+        int[] counter = new int[m + 1];
+        foreach (int num in nums) {
+            counter[num]++;
+        }
+        // 3. Обойти counter и заполнить исходный массив nums элементами
+        int i = 0;
+        for (int num = 0; num < m + 1; num++) {
+            for (int j = 0; j < counter[num]; j++, i++) {
+                nums[i] = num;
+            }
+        }
+    }
+
+    /* Сортировка подсчетом */
+    // Полная реализация, позволяет сортировать объекты и является стабильной сортировкой
+    void CountingSort(int[] nums) {
+        // 1. Найти максимальный элемент массива m
+        int m = 0;
+        foreach (int num in nums) {
+            m = Math.Max(m, num);
+        }
+        // 2. Подсчитать число появлений каждой цифры
+        // counter[num] обозначает число появлений num
+        int[] counter = new int[m + 1];
+        foreach (int num in nums) {
+            counter[num]++;
+        }
+        // 3. Вычислить префиксные суммы counter и преобразовать «число появлений» в «конечный индекс»
+        // То есть counter[num]-1 — это индекс последнего появления num в res
+        for (int i = 0; i < m; i++) {
+            counter[i + 1] += counter[i];
+        }
+        // 4. Обойти nums в обратном порядке и поместить элементы в результирующий массив res
+        // Инициализировать массив res для хранения результата
+        int n = nums.Length;
+        int[] res = new int[n];
+        for (int i = n - 1; i >= 0; i--) {
+            int num = nums[i];
+            res[counter[num] - 1] = num; // Поместить num по соответствующему индексу
+            counter[num]--; // Уменьшить префиксную сумму на 1, чтобы получить индекс следующего размещения num
+        }
+        // Перезаписать исходный массив nums массивом результата res
+        for (int i = 0; i < n; i++) {
+            nums[i] = res[i];
+        }
+    }
+
+    [Test]
+    public void Test() {
+        int[] nums = [1, 0, 1, 2, 0, 4, 0, 2, 2, 4];
+        CountingSortNaive(nums);
+        Console.WriteLine("После сортировки подсчетом (объекты не поддерживаются) nums = " + string.Join(" ", nums));
+
+        int[] nums1 = [1, 0, 1, 2, 0, 4, 0, 2, 2, 4];
+        CountingSort(nums1);
+        Console.WriteLine("После сортировки подсчетом nums1 = " + string.Join(" ", nums));
+    }
+}

ru/codes/csharp/chapter_sorting/heap_sort.cs

@@ -0,0 +1,52 @@
+/**
+* File: heap_sort.cs
+* Created Time: 2023-06-01
+* Author: hpstory (hpstory1024@163.com)
+*/
+
+namespace hello_algo.chapter_sorting;
+
+public class heap_sort {
+    /* Длина кучи равна n; начиная с узла i, выполнить просеивание сверху вниз */
+    void SiftDown(int[] nums, int n, int i) {
+        while (true) {
+            // Определить узел с максимальным значением среди i, l и r и обозначить его как ma
+            int l = 2 * i + 1;
+            int r = 2 * i + 2;
+            int ma = i;
+            if (l < n && nums[l] > nums[ma])
+                ma = l;
+            if (r < n && nums[r] > nums[ma])
+                ma = r;
+            // Если узел i уже максимален или индексы l и r вне границ, дальнейшее просеивание не требуется, выйти
+            if (ma == i)
+                break;
+            // Поменять два узла местами
+            (nums[ma], nums[i]) = (nums[i], nums[ma]);
+            // Циклическое просеивание вниз
+            i = ma;
+        }
+    }
+
+    /* Сортировка кучей */
+    void HeapSort(int[] nums) {
+        // Построение кучи: выполнить heapify для всех узлов, кроме листовых
+        for (int i = nums.Length / 2 - 1; i >= 0; i--) {
+            SiftDown(nums, nums.Length, i);
+        }
+        // Извлекать максимальный элемент из кучи в течение n-1 итераций
+        for (int i = nums.Length - 1; i > 0; i--) {
+            // Поменять корневой узел с самым правым листом местами (поменять первый и последний элементы)
+            (nums[i], nums[0]) = (nums[0], nums[i]);
+            // Начиная с корневого узла, выполнить просеивание сверху вниз
+            SiftDown(nums, i, 0);
+        }
+    }
+
+    [Test]
+    public void Test() {
+        int[] nums = [4, 1, 3, 1, 5, 2];
+        HeapSort(nums);
+        Console.WriteLine("После сортировки кучей nums = " + string.Join(" ", nums));
+    }
+}

ru/codes/csharp/chapter_sorting/insertion_sort.cs

@@ -0,0 +1,30 @@
+/**
+ * File: insertion_sort.cs
+ * Created Time: 2022-12-23
+ * Author: haptear (haptear@hotmail.com)
+ */
+
+namespace hello_algo.chapter_sorting;
+
+public class insertion_sort {
+    /* Сортировка вставками */
+    void InsertionSort(int[] nums) {
+        // Внешний цикл: отсортированный диапазон [0, i-1]
+        for (int i = 1; i < nums.Length; i++) {
+            int bas = nums[i], j = i - 1;
+            // Внутренний цикл: вставить base в правильную позицию отсортированного диапазона [0, i-1]
+            while (j >= 0 && nums[j] > bas) {
+                nums[j + 1] = nums[j]; // Сдвинуть nums[j] на одну позицию вправо
+                j--;
+            }
+            nums[j + 1] = bas;         // Поместить base в правильную позицию
+        }
+    }
+
+    [Test]
+    public void Test() {
+        int[] nums = [4, 1, 3, 1, 5, 2];
+        InsertionSort(nums);
+        Console.WriteLine("После сортировки вставками nums = " + string.Join(",", nums));
+    }
+}

ru/codes/csharp/chapter_sorting/merge_sort.cs

@@ -0,0 +1,56 @@
+/**
+ * File: merge_sort.cs
+ * Created Time: 2022-12-23
+ * Author: haptear (haptear@hotmail.com)
+ */
+
+namespace hello_algo.chapter_sorting;
+
+public class merge_sort {
+    /* Объединить левый и правый подмассивы */
+    void Merge(int[] nums, int left, int mid, int right) {
+        // Диапазон левого подмассива: [left, mid], диапазон правого подмассива: [mid+1, right]
+        // Создать временный массив tmp для хранения результата слияния
+        int[] tmp = new int[right - left + 1];
+        // Инициализировать начальные индексы левого и правого подмассивов
+        int i = left, j = mid + 1, k = 0;
+        // Пока в левом и правом подмассивах еще есть элементы, сравнивать их и копировать меньший во временный массив
+        while (i <= mid && j <= right) {
+            if (nums[i] <= nums[j])
+                tmp[k++] = nums[i++];
+            else
+                tmp[k++] = nums[j++];
+        }
+        // Скопировать оставшиеся элементы левого и правого подмассивов во временный массив
+        while (i <= mid) {
+            tmp[k++] = nums[i++];
+        }
+        while (j <= right) {
+            tmp[k++] = nums[j++];
+        }
+        // Скопировать элементы временного массива tmp обратно в соответствующий диапазон исходного массива nums
+        for (k = 0; k < tmp.Length; ++k) {
+            nums[left + k] = tmp[k];
+        }
+    }
+
+    /* Сортировка слиянием */
+    void MergeSort(int[] nums, int left, int right) {
+        // Условие завершения
+        if (left >= right) return;       // Завершить рекурсию, когда длина подмассива равна 1
+        // Этап разбиения
+        int mid = left + (right - left) / 2;    // Вычислить середину
+        MergeSort(nums, left, mid);      // Рекурсивно обработать левый подмассив
+        MergeSort(nums, mid + 1, right); // Рекурсивно обработать правый подмассив
+        // Этап слияния
+        Merge(nums, left, mid, right);
+    }
+
+    [Test]
+    public void Test() {
+        /* Сортировка слиянием */
+        int[] nums = [7, 3, 2, 6, 0, 1, 5, 4];
+        MergeSort(nums, 0, nums.Length - 1);
+        Console.WriteLine("После сортировки слиянием nums = " + string.Join(",", nums));
+    }
+}

ru/codes/csharp/chapter_sorting/quick_sort.cs

@@ -0,0 +1,150 @@
+/**
+ * File: quick_sort.cs
+ * Created Time: 2022-12-23
+ * Author: haptear (haptear@hotmail.com)
+ */
+
+namespace hello_algo.chapter_sorting;
+
+class quickSort {
+    /* Обмен элементов */
+    static void Swap(int[] nums, int i, int j) {
+        (nums[j], nums[i]) = (nums[i], nums[j]);
+    }
+
+    /* Разбиение с опорными указателями */
+    static int Partition(int[] nums, int left, int right) {
+        // Взять nums[left] в качестве опорного элемента
+        int i = left, j = right;
+        while (i < j) {
+            while (i < j && nums[j] >= nums[left])
+                j--;          // Идти справа налево в поисках первого элемента меньше опорного
+            while (i < j && nums[i] <= nums[left])
+                i++;          // Идти слева направо в поисках первого элемента больше опорного
+            Swap(nums, i, j); // Поменять эти два элемента местами
+        }
+        Swap(nums, i, left);  // Переместить опорный элемент на границу двух подмассивов
+        return i;             // Вернуть индекс опорного элемента
+    }
+
+    /* Быстрая сортировка */
+    public static void QuickSort(int[] nums, int left, int right) {
+        // Завершить рекурсию, когда длина подмассива равна 1
+        if (left >= right)
+            return;
+        // Разбиение с опорными указателями
+        int pivot = Partition(nums, left, right);
+        // Рекурсивно обработать левый и правый подмассивы
+        QuickSort(nums, left, pivot - 1);
+        QuickSort(nums, pivot + 1, right);
+    }
+}
+
+/* Класс быстрой сортировки (оптимизация медианным опорным элементом) */
+class QuickSortMedian {
+    /* Обмен элементов */
+    static void Swap(int[] nums, int i, int j) {
+        (nums[j], nums[i]) = (nums[i], nums[j]);
+    }
+
+    /* Выбрать медиану из трех кандидатов */
+    static int MedianThree(int[] nums, int left, int mid, int right) {
+        int l = nums[left], m = nums[mid], r = nums[right];
+        if ((l <= m && m <= r) || (r <= m && m <= l))
+            return mid; // m находится между l и r
+        if ((m <= l && l <= r) || (r <= l && l <= m))
+            return left; // l находится между m и r
+        return right;
+    }
+
+    /* Разбиение с опорными указателями (медиана трех) */
+    static int Partition(int[] nums, int left, int right) {
+        // Выбрать медиану из трех кандидатов
+        int med = MedianThree(nums, left, (left + right) / 2, right);
+        // Переместить медиану в крайний левый элемент массива
+        Swap(nums, left, med);
+        // Взять nums[left] в качестве опорного элемента
+        int i = left, j = right;
+        while (i < j) {
+            while (i < j && nums[j] >= nums[left])
+                j--;          // Идти справа налево в поисках первого элемента меньше опорного
+            while (i < j && nums[i] <= nums[left])
+                i++;          // Идти слева направо в поисках первого элемента больше опорного
+            Swap(nums, i, j); // Поменять эти два элемента местами
+        }
+        Swap(nums, i, left);  // Переместить опорный элемент на границу двух подмассивов
+        return i;             // Вернуть индекс опорного элемента
+    }
+
+    /* Быстрая сортировка */
+    public static void QuickSort(int[] nums, int left, int right) {
+        // Завершить рекурсию, когда длина подмассива равна 1
+        if (left >= right)
+            return;
+        // Разбиение с опорными указателями
+        int pivot = Partition(nums, left, right);
+        // Рекурсивно обработать левый и правый подмассивы
+        QuickSort(nums, left, pivot - 1);
+        QuickSort(nums, pivot + 1, right);
+    }
+}
+
+/* Класс быстрой сортировки (оптимизация глубины рекурсии) */
+class QuickSortTailCall {
+    /* Обмен элементов */
+    static void Swap(int[] nums, int i, int j) {
+        (nums[j], nums[i]) = (nums[i], nums[j]);
+    }
+
+    /* Разбиение с опорными указателями */
+    static int Partition(int[] nums, int left, int right) {
+        // Взять nums[left] в качестве опорного элемента
+        int i = left, j = right;
+        while (i < j) {
+            while (i < j && nums[j] >= nums[left])
+                j--;          // Идти справа налево в поисках первого элемента меньше опорного
+            while (i < j && nums[i] <= nums[left])
+                i++;          // Идти слева направо в поисках первого элемента больше опорного
+            Swap(nums, i, j); // Поменять эти два элемента местами
+        }
+        Swap(nums, i, left);  // Переместить опорный элемент на границу двух подмассивов
+        return i; // Вернуть индекс опорного элемента
+    }
+
+    /* Быстрая сортировка (оптимизация глубины рекурсии) */
+    public static void QuickSort(int[] nums, int left, int right) {
+        // Завершить, когда длина подмассива равна 1
+        while (left < right) {
+            // Операция разбиения с опорными указателями
+            int pivot = Partition(nums, left, right);
+            // Выполнить быструю сортировку для более короткого из двух подмассивов
+            if (pivot - left < right - pivot) {
+                QuickSort(nums, left, pivot - 1);  // Рекурсивно отсортировать левый подмассив
+                left = pivot + 1;  // Оставшийся неотсортированный диапазон: [pivot + 1, right]
+            } else {
+                QuickSort(nums, pivot + 1, right); // Рекурсивно отсортировать правый подмассив
+                right = pivot - 1; // Оставшийся неотсортированный диапазон: [left, pivot - 1]
+            }
+        }
+    }
+}
+
+public class quick_sort {
+    [Test]
+    public void Test() {
+        /* Быстрая сортировка */
+        int[] nums = [2, 4, 1, 0, 3, 5];
+        quickSort.QuickSort(nums, 0, nums.Length - 1);
+        Console.WriteLine("После быстрой сортировки nums = " + string.Join(",", nums));
+
+        /* Быстрая сортировка (оптимизация медианным опорным элементом) */
+        int[] nums1 = [2, 4, 1, 0, 3, 5];
+        QuickSortMedian.QuickSort(nums1, 0, nums1.Length - 1);
+        Console.WriteLine("После быстрой сортировки (оптимизация медианным опорным элементом) nums1 = " + string.Join(",", nums1));
+
+        /* Быстрая сортировка (оптимизация глубины рекурсии) */
+        int[] nums2 = [2, 4, 1, 0, 3, 5];
+        QuickSortTailCall.QuickSort(nums2, 0, nums2.Length - 1);
+        Console.WriteLine("После быстрой сортировки (оптимизация глубины рекурсии) nums2 = " + string.Join(",", nums2));
+    }
+}

ru/codes/csharp/chapter_sorting/radix_sort.cs

@@ -0,0 +1,69 @@
+/**
+ * File: radix_sort.cs
+ * Created Time: 2023-04-13
+ * Author: hpstory (hpstory1024@163.com)
+ */
+
+namespace hello_algo.chapter_sorting;
+
+public class radix_sort {
+    /* Получить k-й разряд элемента num, где exp = 10^(k-1) */
+    int Digit(int num, int exp) {
+        // Передача exp вместо k позволяет избежать повторного дорогостоящего вычисления степени
+        return (num / exp) % 10;
+    }
+
+    /* Сортировка подсчетом (сортировка по k-му разряду nums) */
+    void CountingSortDigit(int[] nums, int exp) {
+        // Разряды десятичной системы лежат в диапазоне 0~9, поэтому нужен массив корзин длины 10
+        int[] counter = new int[10];
+        int n = nums.Length;
+        // Подсчитать число появлений каждой цифры от 0 до 9
+        for (int i = 0; i < n; i++) {
+            int d = Digit(nums[i], exp); // Получить k-й разряд nums[i], обозначив его как d
+            counter[d]++;                // Подсчитать число появлений цифры d
+        }
+        // Вычислить префиксные суммы и преобразовать «число появлений» в «индекс массива»
+        for (int i = 1; i < 10; i++) {
+            counter[i] += counter[i - 1];
+        }
+        // Выполняя обратный проход, заполнить res элементами по статистике в корзинах
+        int[] res = new int[n];
+        for (int i = n - 1; i >= 0; i--) {
+            int d = Digit(nums[i], exp);
+            int j = counter[d] - 1; // Получить индекс j цифры d в массиве
+            res[j] = nums[i];       // Поместить текущий элемент по индексу j
+            counter[d]--;           // Уменьшить количество d на 1
+        }
+        // Перезаписать исходный массив nums результатом
+        for (int i = 0; i < n; i++) {
+            nums[i] = res[i];
+        }
+    }
+
+    /* Поразрядная сортировка */
+    void RadixSort(int[] nums) {
+        // Получить максимальный элемент массива, чтобы определить максимальное число разрядов
+        int m = int.MinValue;
+        foreach (int num in nums) {
+            if (num > m) m = num;
+        }
+        // Проходить разряды от младшего к старшему
+        for (int exp = 1; exp <= m; exp *= 10) {
+            // Выполнить сортировку подсчетом по k-му разряду элементов массива
+            // k = 1 -> exp = 1
+            // k = 2 -> exp = 10
+            // то есть exp = 10^(k-1)
+            CountingSortDigit(nums, exp);
+        }
+    }
+
+    [Test]
+    public void Test() {
+        // Поразрядная сортировка
+        int[] nums = [ 10546151, 35663510, 42865989, 34862445, 81883077,
+            88906420, 72429244, 30524779, 82060337, 63832996 ];
+        RadixSort(nums);
+        Console.WriteLine("После поразрядной сортировки nums = " + string.Join(" ", nums));
+    }
+}

ru/codes/csharp/chapter_sorting/selection_sort.cs

@@ -0,0 +1,32 @@
+/**
+* File: selection_sort.cs
+* Created Time: 2023-06-01
+* Author: hpstory (hpstory1024@163.com)
+*/
+
+namespace hello_algo.chapter_sorting;
+
+public class selection_sort {
+    /* Сортировка выбором */
+    void SelectionSort(int[] nums) {
+        int n = nums.Length;
+        // Внешний цикл: неотсортированный диапазон [i, n-1]
+        for (int i = 0; i < n - 1; i++) {
+            // Внутренний цикл: найти минимальный элемент в неотсортированном диапазоне
+            int k = i;
+            for (int j = i + 1; j < n; j++) {
+                if (nums[j] < nums[k])
+                    k = j; // Записать индекс минимального элемента
+            }
+            // Поменять этот минимальный элемент местами с первым элементом неотсортированного диапазона
+            (nums[k], nums[i]) = (nums[i], nums[k]);
+        }
+    }
+
+    [Test]
+    public void Test() {
+        int[] nums = [4, 1, 3, 1, 5, 2];
+        SelectionSort(nums);
+        Console.WriteLine("После сортировки выбором nums = " + string.Join(" ", nums));
+    }
+}

ru/codes/csharp/chapter_stack_and_queue/array_deque.cs

@@ -0,0 +1,152 @@
+/**
+ * File: array_deque.cs
+ * Created Time: 2023-03-08
+ * Author: hpstory (hpstory1024@163.com)
+ */
+
+namespace hello_algo.chapter_stack_and_queue;
+
+/* Двусторонняя очередь на основе кольцевого массива */
+public class ArrayDeque {
+    int[] nums;  // Массив для хранения элементов двусторонней очереди
+    int front;   // Указатель head, указывающий на первый элемент очереди
+    int queSize; // Длина двусторонней очереди
+
+    /* Конструктор */
+    public ArrayDeque(int capacity) {
+        nums = new int[capacity];
+        front = queSize = 0;
+    }
+
+    /* Получить вместимость двусторонней очереди */
+    int Capacity() {
+        return nums.Length;
+    }
+
+    /* Получение длины двусторонней очереди */
+    public int Size() {
+        return queSize;
+    }
+
+    /* Проверка, пуста ли двусторонняя очередь */
+    public bool IsEmpty() {
+        return queSize == 0;
+    }
+
+    /* Вычислить индекс в кольцевом массиве */
+    int Index(int i) {
+        // С помощью операции взятия по модулю соединить начало и конец массива
+        // Когда i выходит за конец массива, он возвращается в начало
+        // Когда i выходит за начало массива, он возвращается в конец
+        return (i + Capacity()) % Capacity();
+    }
+
+    /* Добавление в голову очереди */
+    public void PushFirst(int num) {
+        if (queSize == Capacity()) {
+            Console.WriteLine("Двусторонняя очередь заполнена");
+            return;
+        }
+        // Указатель головы сдвигается на одну позицию влево
+        // С помощью операции взятия по модулю front после выхода за начало массива возвращается в хвост
+        front = Index(front - 1);
+        // Добавить num в голову очереди
+        nums[front] = num;
+        queSize++;
+    }
+
+    /* Добавление в хвост очереди */
+    public void PushLast(int num) {
+        if (queSize == Capacity()) {
+            Console.WriteLine("Двусторонняя очередь заполнена");
+            return;
+        }
+        // Вычислить указатель хвоста, указывающий на индекс хвоста + 1
+        int rear = Index(front + queSize);
+        // Добавить num в хвост очереди
+        nums[rear] = num;
+        queSize++;
+    }
+
+    /* Извлечение из головы очереди */
+    public int PopFirst() {
+        int num = PeekFirst();
+        // Указатель головы сдвигается на одну позицию назад
+        front = Index(front + 1);
+        queSize--;
+        return num;
+    }
+
+    /* Извлечение из хвоста очереди */
+    public int PopLast() {
+        int num = PeekLast();
+        queSize--;
+        return num;
+    }
+
+    /* Доступ к элементу в начале очереди */
+    public int PeekFirst() {
+        if (IsEmpty()) {
+            throw new InvalidOperationException();
+        }
+        return nums[front];
+    }
+
+    /* Доступ к элементу в конце очереди */
+    public int PeekLast() {
+        if (IsEmpty()) {
+            throw new InvalidOperationException();
+        }
+        // Вычислить индекс хвостового элемента
+        int last = Index(front + queSize - 1);
+        return nums[last];
+    }
+
+    /* Вернуть массив для вывода */
+    public int[] ToArray() {
+        // Преобразовывать только элементы списка в пределах фактической длины
+        int[] res = new int[queSize];
+        for (int i = 0, j = front; i < queSize; i++, j++) {
+            res[i] = nums[Index(j)];
+        }
+        return res;
+    }
+}
+
+public class array_deque {
+    [Test]
+    public void Test() {
+        /* Инициализация двусторонней очереди */
+        ArrayDeque deque = new(10);
+        deque.PushLast(3);
+        deque.PushLast(2);
+        deque.PushLast(5);
+        Console.WriteLine("Двусторонняя очередь deque = " + string.Join(" ", deque.ToArray()));
+
+        /* Доступ к элементу */
+        int peekFirst = deque.PeekFirst();
+        Console.WriteLine("Первый элемент peekFirst = " + peekFirst);
+        int peekLast = deque.PeekLast();
+        Console.WriteLine("Последний элемент peekLast = " + peekLast);
+
+        /* Добавление элемента в очередь */
+        deque.PushLast(4);
+        Console.WriteLine("После добавления элемента 4 в хвост deque = " + string.Join(" ", deque.ToArray()));
+        deque.PushFirst(1);
+        Console.WriteLine("После добавления элемента 1 в голову deque = " + string.Join(" ", deque.ToArray()));
+
+        /* Извлечение элемента из очереди */
+        int popLast = deque.PopLast();
+        Console.WriteLine("Извлеченный из хвоста элемент = " + popLast + ", deque после извлечения из хвоста = " + string.Join(" ", deque.ToArray()));
+        int popFirst = deque.PopFirst();
+        Console.WriteLine("Извлеченный из головы элемент = " + popFirst + ", deque после извлечения из головы = " + string.Join(" ", deque.ToArray()));
+
+        /* Получение длины двусторонней очереди */
+        int size = deque.Size();
+        Console.WriteLine("Длина двусторонней очереди size = " + size);
+
+        /* Проверка, пуста ли двусторонняя очередь */
+        bool isEmpty = deque.IsEmpty();
+        Console.WriteLine("Пуста ли двусторонняя очередь = " + isEmpty);
+    }
+}

ru/codes/csharp/chapter_stack_and_queue/array_queue.cs

@@ -0,0 +1,114 @@
+/**
+ * File: array_queue.cs
+ * Created Time: 2022-12-23
+ * Author: haptear (haptear@hotmail.com)
+ */
+
+namespace hello_algo.chapter_stack_and_queue;
+
+/* Очередь на основе кольцевого массива */
+class ArrayQueue {
+    int[] nums;  // Массив для хранения элементов очереди
+    int front;   // Указатель head, указывающий на первый элемент очереди
+    int queSize; // Длина очереди
+
+    public ArrayQueue(int capacity) {
+        nums = new int[capacity];
+        front = queSize = 0;
+    }
+
+    /* Получить вместимость очереди */
+    int Capacity() {
+        return nums.Length;
+    }
+
+    /* Получение длины очереди */
+    public int Size() {
+        return queSize;
+    }
+
+    /* Проверка, пуста ли очередь */
+    public bool IsEmpty() {
+        return queSize == 0;
+    }
+
+    /* Поместить в очередь */
+    public void Push(int num) {
+        if (queSize == Capacity()) {
+            Console.WriteLine("Очередь заполнена");
+            return;
+        }
+        // Вычислить указатель хвоста, указывающий на индекс хвоста + 1
+        // С помощью операции взятия по модулю вернуть rear к началу после выхода за конец массива
+        int rear = (front + queSize) % Capacity();
+        // Добавить num в хвост очереди
+        nums[rear] = num;
+        queSize++;
+    }
+
+    /* Извлечь из очереди */
+    public int Pop() {
+        int num = Peek();
+        // Указатель head сдвигается на одну позицию назад; если он выходит за конец, то возвращается в начало массива
+        front = (front + 1) % Capacity();
+        queSize--;
+        return num;
+    }
+
+    /* Доступ к элементу в начале очереди */
+    public int Peek() {
+        if (IsEmpty())
+            throw new Exception();
+        return nums[front];
+    }
+
+    /* Вернуть массив */
+    public int[] ToArray() {
+        // Преобразовывать только элементы списка в пределах фактической длины
+        int[] res = new int[queSize];
+        for (int i = 0, j = front; i < queSize; i++, j++) {
+            res[i] = nums[j % this.Capacity()];
+        }
+        return res;
+    }
+}
+
+public class array_queue {
+    [Test]
+    public void Test() {
+        /* Инициализация очереди */
+        int capacity = 10;
+        ArrayQueue queue = new(capacity);
+
+        /* Добавление элемента в очередь */
+        queue.Push(1);
+        queue.Push(3);
+        queue.Push(2);
+        queue.Push(5);
+        queue.Push(4);
+        Console.WriteLine("Очередь queue = " + string.Join(",", queue.ToArray()));
+
+        /* Доступ к элементу в начале очереди */
+        int peek = queue.Peek();
+        Console.WriteLine("Первый элемент peek = " + peek);
+
+        /* Извлечение элемента из очереди */
+        int pop = queue.Pop();
+        Console.WriteLine("Извлеченный элемент pop = " + pop + ", queue после извлечения = " + string.Join(",", queue.ToArray()));
+
+        /* Получение длины очереди */
+        int size = queue.Size();
+        Console.WriteLine("Длина очереди size = " + size);
+
+        /* Проверка, пуста ли очередь */
+        bool isEmpty = queue.IsEmpty();
+        Console.WriteLine("Пуста ли очередь = " + isEmpty);
+
+        /* Проверка кольцевого массива */
+        for (int i = 0; i < 10; i++) {
+            queue.Push(i);
+            queue.Pop();
+            Console.WriteLine("После " + i + "-го раунда операций enqueue и dequeue queue = " + string.Join(",", queue.ToArray()));
+        }
+    }
+}

ru/codes/csharp/chapter_stack_and_queue/array_stack.cs

@@ -0,0 +1,84 @@
+/**
+ * File: array_stack.cs
+ * Created Time: 2022-12-23
+ * Author: haptear (haptear@hotmail.com)
+ */
+
+namespace hello_algo.chapter_stack_and_queue;
+
+/* Стек на основе массива */
+class ArrayStack {
+    List<int> stack;
+    public ArrayStack() {
+        // Инициализация списка (динамического массива)
+        stack = [];
+    }
+
+    /* Получение длины стека */
+    public int Size() {
+        return stack.Count;
+    }
+
+    /* Проверка, пуст ли стек */
+    public bool IsEmpty() {
+        return Size() == 0;
+    }
+
+    /* Поместить в стек */
+    public void Push(int num) {
+        stack.Add(num);
+    }
+
+    /* Извлечь из стека */
+    public int Pop() {
+        if (IsEmpty())
+            throw new Exception();
+        var val = Peek();
+        stack.RemoveAt(Size() - 1);
+        return val;
+    }
+
+    /* Доступ к верхнему элементу стека */
+    public int Peek() {
+        if (IsEmpty())
+            throw new Exception();
+        return stack[Size() - 1];
+    }
+
+    /* Преобразовать List в Array и вернуть */
+    public int[] ToArray() {
+        return [.. stack];
+    }
+}
+
+public class array_stack {
+    [Test]
+    public void Test() {
+        /* Инициализация стека */
+        ArrayStack stack = new();
+
+        /* Помещение элемента в стек */
+        stack.Push(1);
+        stack.Push(3);
+        stack.Push(2);
+        stack.Push(5);
+        stack.Push(4);
+        Console.WriteLine("Стек stack = " + string.Join(",", stack.ToArray()));
+
+        /* Доступ к верхнему элементу стека */
+        int peek = stack.Peek();
+        Console.WriteLine("Верхний элемент peek = " + peek);
+
+        /* Извлечение элемента из стека */
+        int pop = stack.Pop();
+        Console.WriteLine("Извлеченный элемент pop = " + pop + ", stack после извлечения = " + string.Join(",", stack.ToArray()));
+
+        /* Получение длины стека */
+        int size = stack.Size();
+        Console.WriteLine("Длина стека size = " + size);
+
+        /* Проверка на пустоту */
+        bool isEmpty = stack.IsEmpty();
+        Console.WriteLine("Пуст ли стек = " + isEmpty);
+    }
+}

ru/codes/csharp/chapter_stack_and_queue/deque.cs

@@ -0,0 +1,44 @@
+/**
+ * File: deque.cs
+ * Created Time: 2022-12-30
+ * Author: moonache (microin1301@outlook.com)
+ */
+
+namespace hello_algo.chapter_stack_and_queue;
+
+public class deque {
+    [Test]
+    public void Test() {
+        /* Инициализация двусторонней очереди */
+        // В C# связный список LinkedList рассматривается как двусторонняя очередь
+        LinkedList<int> deque = new();
+
+        /* Добавление элемента в очередь */
+        deque.AddLast(2);   // Добавить в хвост очереди
+        deque.AddLast(5);
+        deque.AddLast(4);
+        deque.AddFirst(3);  // Добавить в голову очереди
+        deque.AddFirst(1);
+        Console.WriteLine("Двусторонняя очередь deque = " + string.Join(",", deque));
+
+        /* Доступ к элементу */
+        int? peekFirst = deque.First?.Value;  // Элемент в голове очереди
+        Console.WriteLine("Первый элемент peekFirst = " + peekFirst);
+        int? peekLast = deque.Last?.Value;    // Элемент в хвосте очереди
+        Console.WriteLine("Последний элемент peekLast = " + peekLast);
+
+        /* Извлечение элемента из очереди */
+        deque.RemoveFirst();  // Извлечь элемент из головы очереди
+        Console.WriteLine("После извлечения элемента из головы deque = " + string.Join(",", deque));
+        deque.RemoveLast();   // Извлечь элемент из хвоста очереди
+        Console.WriteLine("После извлечения элемента из хвоста deque = " + string.Join(",", deque));
+
+        /* Получение длины двусторонней очереди */
+        int size = deque.Count;
+        Console.WriteLine("Длина двусторонней очереди size = " + size);
+
+        /* Проверка, пуста ли двусторонняя очередь */
+        bool isEmpty = deque.Count == 0;
+        Console.WriteLine("Пуста ли двусторонняя очередь = " + isEmpty);
+    }
+}

ru/codes/csharp/chapter_stack_and_queue/linkedlist_deque.cs

@@ -0,0 +1,177 @@
+/**
+ * File: linkedlist_deque.cs
+ * Created Time: 2023-03-08
+ * Author: hpstory (hpstory1024@163.com)
+ */
+
+namespace hello_algo.chapter_stack_and_queue;
+
+/* Узел двусвязного списка */
+public class ListNode(int val) {
+    public int val = val;       // Значение узла
+    public ListNode? next = null; // Ссылка на узел-преемник
+    public ListNode? prev = null; // Ссылка на узел-предшественник
+}
+
+/* Двусторонняя очередь на основе двусвязного списка */
+public class LinkedListDeque {
+    ListNode? front, rear; // Головной узел front, хвостовой узел rear
+    int queSize = 0;      // Длина двусторонней очереди
+
+    public LinkedListDeque() {
+        front = null;
+        rear = null;
+    }
+
+    /* Получение длины двусторонней очереди */
+    public int Size() {
+        return queSize;
+    }
+
+    /* Проверка, пуста ли двусторонняя очередь */
+    public bool IsEmpty() {
+        return Size() == 0;
+    }
+
+    /* Операция добавления в очередь */
+    void Push(int num, bool isFront) {
+        ListNode node = new(num);
+        // Если связный список пуст, сделать так, чтобы и front, и rear указывали на node
+        if (IsEmpty()) {
+            front = node;
+            rear = node;
+        }
+        // Операция добавления в голову очереди
+        else if (isFront) {
+            // Добавить node в голову списка
+            front!.prev = node;
+            node.next = front;
+            front = node; // Обновить головной узел
+        }
+        // Операция добавления в хвост очереди
+        else {
+            // Добавить node в хвост списка
+            rear!.next = node;
+            node.prev = rear;
+            rear = node;  // Обновить хвостовой узел
+        }
+
+        queSize++; // Обновить длину очереди
+    }
+
+    /* Добавление в голову очереди */
+    public void PushFirst(int num) {
+        Push(num, true);
+    }
+
+    /* Добавление в хвост очереди */
+    public void PushLast(int num) {
+        Push(num, false);
+    }
+
+    /* Операция извлечения из очереди */
+    int? Pop(bool isFront) {
+        if (IsEmpty())
+            throw new Exception();
+        int? val;
+        // Операция извлечения из головы очереди
+        if (isFront) {
+            val = front?.val; // Временно сохранить значение головного узла
+            // Удалить головной узел
+            ListNode? fNext = front?.next;
+            if (fNext != null) {
+                fNext.prev = null;
+                front!.next = null;
+            }
+            front = fNext;   // Обновить головной узел
+        }
+        // Операция извлечения из хвоста очереди
+        else {
+            val = rear?.val;  // Временно сохранить значение хвостового узла
+            // Удалить хвостовой узел
+            ListNode? rPrev = rear?.prev;
+            if (rPrev != null) {
+                rPrev.next = null;
+                rear!.prev = null;
+            }
+            rear = rPrev;    // Обновить хвостовой узел
+        }
+
+        queSize--; // Обновить длину очереди
+        return val;
+    }
+
+    /* Извлечение из головы очереди */
+    public int? PopFirst() {
+        return Pop(true);
+    }
+
+    /* Извлечение из хвоста очереди */
+    public int? PopLast() {
+        return Pop(false);
+    }
+
+    /* Доступ к элементу в начале очереди */
+    public int? PeekFirst() {
+        if (IsEmpty())
+            throw new Exception();
+        return front?.val;
+    }
+
+    /* Доступ к элементу в конце очереди */
+    public int? PeekLast() {
+        if (IsEmpty())
+            throw new Exception();
+        return rear?.val;
+    }
+
+    /* Вернуть массив для вывода */
+    public int?[] ToArray() {
+        ListNode? node = front;
+        int?[] res = new int?[Size()];
+        for (int i = 0; i < res.Length; i++) {
+            res[i] = node?.val;
+            node = node?.next;
+        }
+
+        return res;
+    }
+}
+
+public class linkedlist_deque {
+    [Test]
+    public void Test() {
+        /* Инициализация двусторонней очереди */
+        LinkedListDeque deque = new();
+        deque.PushLast(3);
+        deque.PushLast(2);
+        deque.PushLast(5);
+        Console.WriteLine("Двусторонняя очередь deque = " + string.Join(" ", deque.ToArray()));
+
+        /* Доступ к элементу */
+        int? peekFirst = deque.PeekFirst();
+        Console.WriteLine("Первый элемент peekFirst = " + peekFirst);
+        int? peekLast = deque.PeekLast();
+        Console.WriteLine("Последний элемент peekLast = " + peekLast);
+
+        /* Добавление элемента в очередь */
+        deque.PushLast(4);
+        Console.WriteLine("После добавления элемента 4 в хвост deque = " + string.Join(" ", deque.ToArray()));
+        deque.PushFirst(1);
+        Console.WriteLine("После добавления элемента 1 в голову deque = " + string.Join(" ", deque.ToArray()));
+
+        /* Извлечение элемента из очереди */
+        int? popLast = deque.PopLast();
+        Console.WriteLine("Извлеченный из хвоста элемент = " + popLast + ", deque после извлечения из хвоста = " + string.Join(" ", deque.ToArray()));
+        int? popFirst = deque.PopFirst();
+        Console.WriteLine("Извлеченный из головы элемент = " + popFirst + ", deque после извлечения из головы = " + string.Join(" ", deque.ToArray()));
+
+        /* Получение длины двусторонней очереди */
+        int size = deque.Size();
+        Console.WriteLine("Длина двусторонней очереди size = " + size);
+
+        /* Проверка, пуста ли двусторонняя очередь */
+        bool isEmpty = deque.IsEmpty();
+        Console.WriteLine("Пуста ли двусторонняя очередь = " + isEmpty);
+    }
+}

ru/codes/csharp/chapter_stack_and_queue/linkedlist_queue.cs

@@ -0,0 +1,106 @@
+/**
+ * File: linkedlist_queue.cs
+ * Created Time: 2022-12-23
+ * Author: haptear (haptear@hotmail.com)
+ */
+
+namespace hello_algo.chapter_stack_and_queue;
+
+/* Очередь на основе связного списка */
+class LinkedListQueue {
+    ListNode? front, rear;  // Головной узел front, хвостовой узел rear
+    int queSize = 0;
+
+    public LinkedListQueue() {
+        front = null;
+        rear = null;
+    }
+
+    /* Получение длины очереди */
+    public int Size() {
+        return queSize;
+    }
+
+    /* Проверка, пуста ли очередь */
+    public bool IsEmpty() {
+        return Size() == 0;
+    }
+
+    /* Поместить в очередь */
+    public void Push(int num) {
+        // Добавить num после хвостового узла
+        ListNode node = new(num);
+        // Если очередь пуста, сделать так, чтобы и head, и tail указывали на этот узел
+        if (front == null) {
+            front = node;
+            rear = node;
+            // Если очередь не пуста, добавить этот узел после хвостового узла
+        } else if (rear != null) {
+            rear.next = node;
+            rear = node;
+        }
+        queSize++;
+    }
+
+    /* Извлечь из очереди */
+    public int Pop() {
+        int num = Peek();
+        // Удалить головной узел
+        front = front?.next;
+        queSize--;
+        return num;
+    }
+
+    /* Доступ к элементу в начале очереди */
+    public int Peek() {
+        if (IsEmpty())
+            throw new Exception();
+        return front!.val;
+    }
+
+    /* Преобразовать связный список в Array и вернуть */
+    public int[] ToArray() {
+        if (front == null)
+            return [];
+
+        ListNode? node = front;
+        int[] res = new int[Size()];
+        for (int i = 0; i < res.Length; i++) {
+            res[i] = node!.val;
+            node = node.next;
+        }
+        return res;
+    }
+}
+
+public class linkedlist_queue {
+    [Test]
+    public void Test() {
+        /* Инициализация очереди */
+        LinkedListQueue queue = new();
+
+        /* Добавление элемента в очередь */
+        queue.Push(1);
+        queue.Push(3);
+        queue.Push(2);
+        queue.Push(5);
+        queue.Push(4);
+        Console.WriteLine("Очередь queue = " + string.Join(",", queue.ToArray()));
+
+        /* Доступ к элементу в начале очереди */
+        int peek = queue.Peek();
+        Console.WriteLine("Первый элемент peek = " + peek);
+
+        /* Извлечение элемента из очереди */
+        int pop = queue.Pop();
+        Console.WriteLine("Извлеченный элемент pop = " + pop + ", queue после извлечения = " + string.Join(",", queue.ToArray()));
+
+        /* Получение длины очереди */
+        int size = queue.Size();
+        Console.WriteLine("Длина очереди size = " + size);
+
+        /* Проверка, пуста ли очередь */
+        bool isEmpty = queue.IsEmpty();
+        Console.WriteLine("Пуста ли очередь = " + isEmpty);
+    }
+}

ru/codes/csharp/chapter_stack_and_queue/linkedlist_stack.cs

@@ -0,0 +1,97 @@
+/**
+ * File: linkedlist_stack.cs
+ * Created Time: 2022-12-23
+ * Author: haptear (haptear@hotmail.com)
+ */
+
+namespace hello_algo.chapter_stack_and_queue;
+
+/* Стек на основе связного списка */
+class LinkedListStack {
+    ListNode? stackPeek;  // Использовать головной узел как вершину стека
+    int stkSize = 0;   // Длина стека
+
+    public LinkedListStack() {
+        stackPeek = null;
+    }
+
+    /* Получение длины стека */
+    public int Size() {
+        return stkSize;
+    }
+
+    /* Проверка, пуст ли стек */
+    public bool IsEmpty() {
+        return Size() == 0;
+    }
+
+    /* Поместить в стек */
+    public void Push(int num) {
+        ListNode node = new(num) {
+            next = stackPeek
+        };
+        stackPeek = node;
+        stkSize++;
+    }
+
+    /* Извлечь из стека */
+    public int Pop() {
+        int num = Peek();
+        stackPeek = stackPeek!.next;
+        stkSize--;
+        return num;
+    }
+
+    /* Доступ к верхнему элементу стека */
+    public int Peek() {
+        if (IsEmpty())
+            throw new Exception();
+        return stackPeek!.val;
+    }
+
+    /* Преобразовать List в Array и вернуть */
+    public int[] ToArray() {
+        if (stackPeek == null)
+            return [];
+
+        ListNode? node = stackPeek;
+        int[] res = new int[Size()];
+        for (int i = res.Length - 1; i >= 0; i--) {
+            res[i] = node!.val;
+            node = node.next;
+        }
+        return res;
+    }
+}
+
+public class linkedlist_stack {
+    [Test]
+    public void Test() {
+        /* Инициализация стека */
+        LinkedListStack stack = new();
+
+        /* Помещение элемента в стек */
+        stack.Push(1);
+        stack.Push(3);
+        stack.Push(2);
+        stack.Push(5);
+        stack.Push(4);
+        Console.WriteLine("Стек stack = " + string.Join(",", stack.ToArray()));
+
+        /* Доступ к верхнему элементу стека */
+        int peek = stack.Peek();
+        Console.WriteLine("Верхний элемент peek = " + peek);
+
+        /* Извлечение элемента из стека */
+        int pop = stack.Pop();
+        Console.WriteLine("Извлеченный элемент pop = " + pop + ", stack после извлечения = " + string.Join(",", stack.ToArray()));
+
+        /* Получение длины стека */
+        int size = stack.Size();
+        Console.WriteLine("Длина стека size = " + size);
+
+        /* Проверка на пустоту */
+        bool isEmpty = stack.IsEmpty();
+        Console.WriteLine("Пуст ли стек = " + isEmpty);
+    }
+}

ru/codes/csharp/chapter_stack_and_queue/queue.cs

@@ -0,0 +1,39 @@
+/**
+ * File: queue.cs
+ * Created Time: 2022-12-23
+ * Author: haptear (haptear@hotmail.com)
+ */
+
+namespace hello_algo.chapter_stack_and_queue;
+
+public class queue {
+    [Test]
+    public void Test() {
+        /* Инициализация очереди */
+        Queue<int> queue = new();
+
+        /* Добавление элемента в очередь */
+        queue.Enqueue(1);
+        queue.Enqueue(3);
+        queue.Enqueue(2);
+        queue.Enqueue(5);
+        queue.Enqueue(4);
+        Console.WriteLine("Очередь queue = " + string.Join(",", queue));
+
+        /* Доступ к элементу в начале очереди */
+        int peek = queue.Peek();
+        Console.WriteLine("Первый элемент peek = " + peek);
+
+        /* Извлечение элемента из очереди */
+        int pop = queue.Dequeue();
+        Console.WriteLine("Извлеченный элемент pop = " + pop + ", queue после извлечения = " + string.Join(",", queue));
+
+        /* Получение длины очереди */
+        int size = queue.Count;
+        Console.WriteLine("Длина очереди size = " + size);
+
+        /* Проверка, пуста ли очередь */
+        bool isEmpty = queue.Count == 0;
+        Console.WriteLine("Пуста ли очередь = " + isEmpty);
+    }
+}

ru/codes/csharp/chapter_stack_and_queue/stack.cs

@@ -0,0 +1,40 @@
+/**
+ * File: stack.cs
+ * Created Time: 2022-12-23
+ * Author: haptear (haptear@hotmail.com)
+ */
+
+namespace hello_algo.chapter_stack_and_queue;
+
+public class stack {
+    [Test]
+    public void Test() {
+        /* Инициализация стека */
+        Stack<int> stack = new();
+
+        /* Помещение элемента в стек */
+        stack.Push(1);
+        stack.Push(3);
+        stack.Push(2);
+        stack.Push(5);
+        stack.Push(4);
+        // Обратите внимание: stack.ToArray() возвращает последовательность в обратном порядке, то есть индекс 0 соответствует вершине стека
+        Console.WriteLine("Стек stack = " + string.Join(",", stack));
+
+        /* Доступ к верхнему элементу стека */
+        int peek = stack.Peek();
+        Console.WriteLine("Верхний элемент peek = " + peek);
+
+        /* Извлечение элемента из стека */
+        int pop = stack.Pop();
+        Console.WriteLine("Извлеченный элемент pop = " + pop + ", stack после извлечения = " + string.Join(",", stack));
+
+        /* Получение длины стека */
+        int size = stack.Count;
+        Console.WriteLine("Длина стека size = " + size);
+
+        /* Проверка на пустоту */
+        bool isEmpty = stack.Count == 0;
+        Console.WriteLine("Пуст ли стек = " + isEmpty);
+    }
+}

ru/codes/csharp/chapter_tree/array_binary_tree.cs

@@ -0,0 +1,129 @@
+/**
+* File: array_binary_tree.cs
+* Created Time: 2023-07-20
+* Author: hpstory (hpstory1024@163.com)
+*/
+
+namespace hello_algo.chapter_tree;
+
+/* Класс двоичного дерева в массивном представлении */
+public class ArrayBinaryTree(List<int?> arr) {
+    List<int?> tree = new(arr);
+
+    /* Вместимость списка */
+    public int Size() {
+        return tree.Count;
+    }
+
+    /* Получить значение узла с индексом i */
+    public int? Val(int i) {
+        // Если индекс выходит за границы, вернуть null, обозначающий пустую позицию
+        if (i < 0 || i >= Size())
+            return null;
+        return tree[i];
+    }
+
+    /* Получить индекс левого дочернего узла узла с индексом i */
+    public int Left(int i) {
+        return 2 * i + 1;
+    }
+
+    /* Получить индекс правого дочернего узла узла с индексом i */
+    public int Right(int i) {
+        return 2 * i + 2;
+    }
+
+    /* Получить индекс родительского узла узла с индексом i */
+    public int Parent(int i) {
+        return (i - 1) / 2;
+    }
+
+    /* Обход в ширину */
+    public List<int> LevelOrder() {
+        List<int> res = [];
+        // Непосредственно обходить массив
+        for (int i = 0; i < Size(); i++) {
+            if (Val(i).HasValue)
+                res.Add(Val(i)!.Value);
+        }
+        return res;
+    }
+
+    /* Обход в глубину */
+    void DFS(int i, string order, List<int> res) {
+        // Если это пустая позиция, вернуть
+        if (!Val(i).HasValue)
+            return;
+        // Предварительный обход
+        if (order == "pre")
+            res.Add(Val(i)!.Value);
+        DFS(Left(i), order, res);
+        // Симметричный обход
+        if (order == "in")
+            res.Add(Val(i)!.Value);
+        DFS(Right(i), order, res);
+        // Обратный обход
+        if (order == "post")
+            res.Add(Val(i)!.Value);
+    }
+
+    /* Предварительный обход */
+    public List<int> PreOrder() {
+        List<int> res = [];
+        DFS(0, "pre", res);
+        return res;
+    }
+
+    /* Симметричный обход */
+    public List<int> InOrder() {
+        List<int> res = [];
+        DFS(0, "in", res);
+        return res;
+    }
+
+    /* Обратный обход */
+    public List<int> PostOrder() {
+        List<int> res = [];
+        DFS(0, "post", res);
+        return res;
+    }
+}
+
+public class array_binary_tree {
+    [Test]
+    public void Test() {
+        // Инициализировать двоичное дерево
+        // Здесь используется функция, напрямую строящая двоичное дерево из массива
+        List<int?> arr = [1, 2, 3, 4, null, 6, 7, 8, 9, null, null, 12, null, null, 15];
+
+        TreeNode? root = TreeNode.ListToTree(arr);
+        Console.WriteLine("\nИнициализация двоичного дерева\n");
+        Console.WriteLine("Массивное представление двоичного дерева:");
+        Console.WriteLine(arr.PrintList());
+        Console.WriteLine("Связное представление двоичного дерева:");
+        PrintUtil.PrintTree(root);
+
+        // Класс двоичного дерева в массивном представлении
+        ArrayBinaryTree abt = new(arr);
+
+        // Доступ к узлу
+        int i = 1;
+        int l = abt.Left(i);
+        int r = abt.Right(i);
+        int p = abt.Parent(i);
+        Console.WriteLine("\nТекущий узел: индекс = " + i + " , значение = " + abt.Val(i));
+        Console.WriteLine("Индекс левого дочернего узла = " + l + " , значение = " + (abt.Val(l).HasValue ? abt.Val(l) : "null"));
+        Console.WriteLine("Индекс правого дочернего узла = " + r + " , значение = " + (abt.Val(r).HasValue ? abt.Val(r) : "null"));
+        Console.WriteLine("Индекс родительского узла = " + p + " , значение = " + (abt.Val(p).HasValue ? abt.Val(p) : "null"));
+
+        // Обходить дерево
+        List<int> res = abt.LevelOrder();
+        Console.WriteLine("\nОбход в ширину = " + res.PrintList());
+        res = abt.PreOrder();
+        Console.WriteLine("Предварительный обход = " + res.PrintList());
+        res = abt.InOrder();
+        Console.WriteLine("Симметричный обход = " + res.PrintList());
+        res = abt.PostOrder();
+        Console.WriteLine("Обратный обход = " + res.PrintList());
+    }
+}

ru/codes/csharp/chapter_tree/avl_tree.cs

@@ -0,0 +1,216 @@
+/**
+ * File: avl_tree.cs
+ * Created Time: 2022-12-23
+ * Author: haptear (haptear@hotmail.com)
+ */
+
+namespace hello_algo.chapter_tree;
+
+/* AVL-дерево */
+class AVLTree {
+    public TreeNode? root; // Корневой узел
+
+    /* Получить высоту узла */
+    int Height(TreeNode? node) {
+        // Высота пустого узла равна -1, высота листового узла равна 0
+        return node == null ? -1 : node.height;
+    }
+
+    /* Обновить высоту узла */
+    void UpdateHeight(TreeNode node) {
+        // Высота узла равна высоте более высокого поддерева + 1
+        node.height = Math.Max(Height(node.left), Height(node.right)) + 1;
+    }
+
+    /* Получить коэффициент баланса */
+    public int BalanceFactor(TreeNode? node) {
+        // Коэффициент баланса пустого узла равен 0
+        if (node == null) return 0;
+        // Коэффициент баланса узла = высота левого поддерева - высота правого поддерева
+        return Height(node.left) - Height(node.right);
+    }
+
+    /* Операция правого вращения */
+    TreeNode? RightRotate(TreeNode? node) {
+        TreeNode? child = node?.left;
+        TreeNode? grandChild = child?.right;
+        // Выполнить правое вращение узла node вокруг child
+        child.right = node;
+        node.left = grandChild;
+        // Обновить высоту узла
+        UpdateHeight(node);
+        UpdateHeight(child);
+        // Вернуть корневой узел поддерева после вращения
+        return child;
+    }
+
+    /* Операция левого вращения */
+    TreeNode? LeftRotate(TreeNode? node) {
+        TreeNode? child = node?.right;
+        TreeNode? grandChild = child?.left;
+        // Выполнить левое вращение узла node вокруг child
+        child.left = node;
+        node.right = grandChild;
+        // Обновить высоту узла
+        UpdateHeight(node);
+        UpdateHeight(child);
+        // Вернуть корневой узел поддерева после вращения
+        return child;
+    }
+
+    /* Выполнить вращение, чтобы снова сбалансировать поддерево */
+    TreeNode? Rotate(TreeNode? node) {
+        // Получить коэффициент баланса узла node
+        int balanceFactorInt = BalanceFactor(node);
+        // Левосторонне перекошенное дерево
+        if (balanceFactorInt > 1) {
+            if (BalanceFactor(node?.left) >= 0) {
+                // Правое вращение
+                return RightRotate(node);
+            } else {
+                // Сначала левое вращение, затем правое
+                node!.left = LeftRotate(node!.left);
+                return RightRotate(node);
+            }
+        }
+        // Правосторонне перекошенное дерево
+        if (balanceFactorInt < -1) {
+            if (BalanceFactor(node?.right) <= 0) {
+                // Левое вращение
+                return LeftRotate(node);
+            } else {
+                // Сначала правое вращение, затем левое
+                node!.right = RightRotate(node!.right);
+                return LeftRotate(node);
+            }
+        }
+        // Дерево сбалансировано, вращение не требуется, вернуть сразу
+        return node;
+    }
+
+    /* Вставка узла */
+    public void Insert(int val) {
+        root = InsertHelper(root, val);
+    }
+
+    /* Рекурсивная вставка узла (вспомогательный метод) */
+    TreeNode? InsertHelper(TreeNode? node, int val) {
+        if (node == null) return new TreeNode(val);
+        /* 1. Найти позицию вставки и вставить узел */
+        if (val < node.val)
+            node.left = InsertHelper(node.left, val);
+        else if (val > node.val)
+            node.right = InsertHelper(node.right, val);
+        else
+            return node;     // Повторяющийся узел не вставлять, сразу вернуть
+        UpdateHeight(node);  // Обновить высоту узла
+        /* 2. Выполнить вращение, чтобы снова сбалансировать поддерево */
+        node = Rotate(node);
+        // Вернуть корневой узел поддерева
+        return node;
+    }
+
+    /* Удаление узла */
+    public void Remove(int val) {
+        root = RemoveHelper(root, val);
+    }
+
+    /* Рекурсивное удаление узла (вспомогательный метод) */
+    TreeNode? RemoveHelper(TreeNode? node, int val) {
+        if (node == null) return null;
+        /* 1. Найти узел и удалить его */
+        if (val < node.val)
+            node.left = RemoveHelper(node.left, val);
+        else if (val > node.val)
+            node.right = RemoveHelper(node.right, val);
+        else {
+            if (node.left == null || node.right == null) {
+                TreeNode? child = node.left ?? node.right;
+                // Число дочерних узлов = 0, удалить node и сразу вернуть
+                if (child == null)
+                    return null;
+                // Число дочерних узлов = 1, удалить node напрямую
+                else
+                    node = child;
+            } else {
+                // Число дочерних узлов = 2, удалить следующий по симметричному обходу узел и заменить им текущий узел
+                TreeNode? temp = node.right;
+                while (temp.left != null) {
+                    temp = temp.left;
+                }
+                node.right = RemoveHelper(node.right, temp.val!.Value);
+                node.val = temp.val;
+            }
+        }
+        UpdateHeight(node);  // Обновить высоту узла
+        /* 2. Выполнить вращение, чтобы снова сбалансировать поддерево */
+        node = Rotate(node);
+        // Вернуть корневой узел поддерева
+        return node;
+    }
+
+    /* Поиск узла */
+    public TreeNode? Search(int val) {
+        TreeNode? cur = root;
+        // Искать в цикле и выйти после прохода за листовой узел
+        while (cur != null) {
+            // Целевой узел находится в правом поддереве cur
+            if (cur.val < val)
+                cur = cur.right;
+            // Целевой узел находится в левом поддереве cur
+            else if (cur.val > val)
+                cur = cur.left;
+            // Найти целевой узел и выйти из цикла
+            else
+                break;
+        }
+        // Вернуть целевой узел
+        return cur;
+    }
+}
+
+public class avl_tree {
+    static void TestInsert(AVLTree tree, int val) {
+        tree.Insert(val);
+        Console.WriteLine("\nПосле вставки узла " + val + " AVL-дерево имеет вид");
+        PrintUtil.PrintTree(tree.root);
+    }
+
+    static void TestRemove(AVLTree tree, int val) {
+        tree.Remove(val);
+        Console.WriteLine("\nПосле удаления узла " + val + " AVL-дерево имеет вид");
+        PrintUtil.PrintTree(tree.root);
+    }
+
+    [Test]
+    public void Test() {
+        /* Инициализация пустого AVL-дерева */
+        AVLTree avlTree = new();
+
+        /* Вставка узла */
+        // Обратите внимание, как AVL-дерево сохраняет баланс после вставки узла
+        TestInsert(avlTree, 1);
+        TestInsert(avlTree, 2);
+        TestInsert(avlTree, 3);
+        TestInsert(avlTree, 4);
+        TestInsert(avlTree, 5);
+        TestInsert(avlTree, 8);
+        TestInsert(avlTree, 7);
+        TestInsert(avlTree, 9);
+        TestInsert(avlTree, 10);
+        TestInsert(avlTree, 6);
+
+        /* Вставка повторяющегося узла */
+        TestInsert(avlTree, 7);
+
+        /* Удаление узла */
+        // Обратите внимание, как AVL-дерево сохраняет баланс после удаления узла
+        TestRemove(avlTree, 8); // Удаление узла степени 0
+        TestRemove(avlTree, 5); // Удаление узла степени 1
+        TestRemove(avlTree, 4); // Удаление узла степени 2
+
+        /* Поиск узла */
+        TreeNode? node = avlTree.Search(7);
+        Console.WriteLine("\nНайденный объект узла = " + node + ", значение узла = " + node?.val);
+    }
+}

ru/codes/csharp/chapter_tree/binary_search_tree.cs

@@ -0,0 +1,160 @@
+/**
+ * File: binary_search_tree.cs
+ * Created Time: 2022-12-23
+ * Author: haptear (haptear@hotmail.com)
+ */
+
+namespace hello_algo.chapter_tree;
+
+class BinarySearchTree {
+    TreeNode? root;
+
+    public BinarySearchTree() {
+        // Инициализировать пустое дерево
+        root = null;
+    }
+
+    /* Получить корневой узел двоичного дерева */
+    public TreeNode? GetRoot() {
+        return root;
+    }
+
+    /* Поиск узла */
+    public TreeNode? Search(int num) {
+        TreeNode? cur = root;
+        // Искать в цикле и выйти после прохода за листовой узел
+        while (cur != null) {
+            // Целевой узел находится в правом поддереве cur
+            if (cur.val < num) cur =
+                cur.right;
+            // Целевой узел находится в левом поддереве cur
+            else if (cur.val > num)
+                cur = cur.left;
+            // Найти целевой узел и выйти из цикла
+            else
+                break;
+        }
+        // Вернуть целевой узел
+        return cur;
+    }
+
+    /* Вставка узла */
+    public void Insert(int num) {
+        // Если дерево пусто, инициализировать корневой узел
+        if (root == null) {
+            root = new TreeNode(num);
+            return;
+        }
+        TreeNode? cur = root, pre = null;
+        // Искать в цикле и выйти после прохода за листовой узел
+        while (cur != null) {
+            // Найти повторяющийся узел и сразу вернуть
+            if (cur.val == num)
+                return;
+            pre = cur;
+            // Позиция вставки находится в правом поддереве cur
+            if (cur.val < num)
+                cur = cur.right;
+            // Позиция вставки находится в левом поддереве cur
+            else
+                cur = cur.left;
+        }
+
+        // Вставка узла
+        TreeNode node = new(num);
+        if (pre != null) {
+            if (pre.val < num)
+                pre.right = node;
+            else
+                pre.left = node;
+        }
+    }
+
+
+    /* Удаление узла */
+    public void Remove(int num) {
+        // Если дерево пусто, сразу вернуть
+        if (root == null)
+            return;
+        TreeNode? cur = root, pre = null;
+        // Искать в цикле и выйти после прохода за листовой узел
+        while (cur != null) {
+            // Найти узел для удаления и выйти из цикла
+            if (cur.val == num)
+                break;
+            pre = cur;
+            // Узел для удаления находится в правом поддереве cur
+            if (cur.val < num)
+                cur = cur.right;
+            // Узел для удаления находится в левом поддереве cur
+            else
+                cur = cur.left;
+        }
+        // Если узел для удаления отсутствует, сразу вернуть
+        if (cur == null)
+            return;
+        // Число дочерних узлов = 0 или 1
+        if (cur.left == null || cur.right == null) {
+            // Когда число дочерних узлов = 0 / 1, child = null / этот дочерний узел
+            TreeNode? child = cur.left ?? cur.right;
+            // Удалить узел cur
+            if (cur != root) {
+                if (pre!.left == cur)
+                    pre.left = child;
+                else
+                    pre.right = child;
+            } else {
+                // Если удаляемый узел является корнем, заново назначить корневой узел
+                root = child;
+            }
+        }
+        // Число дочерних узлов = 2
+        else {
+            // Получить следующий узел после cur в симметричном обходе
+            TreeNode? tmp = cur.right;
+            while (tmp.left != null) {
+                tmp = tmp.left;
+            }
+            // Рекурсивно удалить узел tmp
+            Remove(tmp.val!.Value);
+            // Перезаписать cur значением tmp
+            cur.val = tmp.val;
+        }
+    }
+}
+
+public class binary_search_tree {
+    [Test]
+    public void Test() {
+        /* Инициализация двоичного дерева поиска */
+        BinarySearchTree bst = new();
+        // Обратите внимание: разные порядки вставки порождают разные двоичные деревья; данная последовательность может построить совершенное двоичное дерево
+        int[] nums = [8, 4, 12, 2, 6, 10, 14, 1, 3, 5, 7, 9, 11, 13, 15];
+        foreach (int num in nums) {
+            bst.Insert(num);
+        }
+
+        Console.WriteLine("\nИсходное двоичное дерево\n");
+        PrintUtil.PrintTree(bst.GetRoot());
+
+        /* Поиск узла */
+        TreeNode? node = bst.Search(7);
+        Console.WriteLine("\nНайденный объект узла = " + node + ", значение узла = " + node?.val);
+
+        /* Вставка узла */
+        bst.Insert(16);
+        Console.WriteLine("\nПосле вставки узла 16 двоичное дерево имеет вид\n");
+        PrintUtil.PrintTree(bst.GetRoot());
+
+        /* Удаление узла */
+        bst.Remove(1);
+        Console.WriteLine("\nПосле удаления узла 1 двоичное дерево имеет вид\n");
+        PrintUtil.PrintTree(bst.GetRoot());
+        bst.Remove(2);
+        Console.WriteLine("\nПосле удаления узла 2 двоичное дерево имеет вид\n");
+        PrintUtil.PrintTree(bst.GetRoot());
+        bst.Remove(4);
+        Console.WriteLine("\nПосле удаления узла 4 двоичное дерево имеет вид\n");
+        PrintUtil.PrintTree(bst.GetRoot());
+    }
+}

ru/codes/csharp/chapter_tree/binary_tree.cs

@@ -0,0 +1,39 @@
+/**
+ * File: binary_tree.cs
+ * Created Time: 2022-12-23
+ * Author: haptear (haptear@hotmail.com)
+ */
+
+namespace hello_algo.chapter_tree;
+
+public class binary_tree {
+    [Test]
+    public void Test() {
+        /* Инициализация двоичного дерева */
+        // Инициализация узла
+        TreeNode n1 = new(1);
+        TreeNode n2 = new(2);
+        TreeNode n3 = new(3);
+        TreeNode n4 = new(4);
+        TreeNode n5 = new(5);
+        // Построить связи между узлами (указатели)
+        n1.left = n2;
+        n1.right = n3;
+        n2.left = n4;
+        n2.right = n5;
+        Console.WriteLine("\nИнициализация двоичного дерева\n");
+        PrintUtil.PrintTree(n1);
+
+        /* Вставка и удаление узлов */
+        TreeNode P = new(0);
+        // Вставить узел P между n1 -> n2
+        n1.left = P;
+        P.left = n2;
+        Console.WriteLine("\nПосле вставки узла P\n");
+        PrintUtil.PrintTree(n1);
+        // Удалить узел P
+        n1.left = n2;
+        Console.WriteLine("\nПосле удаления узла P\n");
+        PrintUtil.PrintTree(n1);
+    }
+}

ru/codes/csharp/chapter_tree/binary_tree_bfs.cs

@@ -0,0 +1,40 @@
+/**
+ * File: binary_tree_bfs.cs
+ * Created Time: 2022-12-23
+ * Author: haptear (haptear@hotmail.com)
+ */
+
+namespace hello_algo.chapter_tree;
+
+public class binary_tree_bfs {
+
+    /* Обход в ширину */
+    List<int> LevelOrder(TreeNode root) {
+        // Инициализировать очередь и добавить корневой узел
+        Queue<TreeNode> queue = new();
+        queue.Enqueue(root);
+        // Инициализировать список для хранения последовательности обхода
+        List<int> list = [];
+        while (queue.Count != 0) {
+            TreeNode node = queue.Dequeue(); // Извлечение из очереди
+            list.Add(node.val!.Value);       // Сохранить значение узла
+            if (node.left != null)
+                queue.Enqueue(node.left);    // Поместить левый дочерний узел в очередь
+            if (node.right != null)
+                queue.Enqueue(node.right);   // Поместить правый дочерний узел в очередь
+        }
+        return list;
+    }
+
+    [Test]
+    public void Test() {
+        /* Инициализация двоичного дерева */
+        // Здесь используется функция, напрямую строящая двоичное дерево из массива
+        TreeNode? root = TreeNode.ListToTree([1, 2, 3, 4, 5, 6, 7]);
+        Console.WriteLine("\nИнициализация двоичного дерева\n");
+        PrintUtil.PrintTree(root);
+
+        List<int> list = LevelOrder(root!);
+        Console.WriteLine("\nПоследовательность печати узлов при обходе в ширину = " + string.Join(",", list));
+    }
+}

ru/codes/csharp/chapter_tree/binary_tree_dfs.cs

@@ -0,0 +1,59 @@
+/**
+ * File: binary_tree_dfs.cs
+ * Created Time: 2022-12-23
+ * Author: haptear (haptear@hotmail.com)
+ */
+
+namespace hello_algo.chapter_tree;
+
+public class binary_tree_dfs {
+    List<int> list = [];
+
+    /* Предварительный обход */
+    void PreOrder(TreeNode? root) {
+        if (root == null) return;
+        // Порядок обхода: корень -> левое поддерево -> правое поддерево
+        list.Add(root.val!.Value);
+        PreOrder(root.left);
+        PreOrder(root.right);
+    }
+
+    /* Симметричный обход */
+    void InOrder(TreeNode? root) {
+        if (root == null) return;
+        // Порядок обхода: левое поддерево -> корень -> правое поддерево
+        InOrder(root.left);
+        list.Add(root.val!.Value);
+        InOrder(root.right);
+    }
+
+    /* Обратный обход */
+    void PostOrder(TreeNode? root) {
+        if (root == null) return;
+        // Порядок обхода: левое поддерево -> правое поддерево -> корень
+        PostOrder(root.left);
+        PostOrder(root.right);
+        list.Add(root.val!.Value);
+    }
+
+    [Test]
+    public void Test() {
+        /* Инициализация двоичного дерева */
+        // Здесь используется функция, напрямую строящая двоичное дерево из массива
+        TreeNode? root = TreeNode.ListToTree([1, 2, 3, 4, 5, 6, 7]);
+        Console.WriteLine("\nИнициализация двоичного дерева\n");
+        PrintUtil.PrintTree(root);
+
+        list.Clear();
+        PreOrder(root);
+        Console.WriteLine("\nПоследовательность печати узлов при предварительном обходе = " + string.Join(",", list));
+
+        list.Clear();
+        InOrder(root);
+        Console.WriteLine("\nПоследовательность печати узлов при симметричном обходе = " + string.Join(",", list));
+
+        list.Clear();
+        PostOrder(root);
+        Console.WriteLine("\nПоследовательность печати узлов при обратном обходе = " + string.Join(",", list));
+    }
+}

ru/codes/csharp/csharp.sln

@@ -0,0 +1,25 @@
+
+Microsoft Visual Studio Solution File, Format Version 12.00
+# Visual Studio Version 17
+VisualStudioVersion = 17.5.002.0
+MinimumVisualStudioVersion = 10.0.40219.1
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "hello-algo", "hello-algo.csproj", "{48B60439-EFDC-4C8F-AE8D-41979958C8AC}"
+EndProject
+Global
+	GlobalSection(SolutionConfigurationPlatforms) = preSolution
+		Debug|Any CPU = Debug|Any CPU
+		Release|Any CPU = Release|Any CPU
+	EndGlobalSection
+	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{48B60439-EFDC-4C8F-AE8D-41979958C8AC}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{48B60439-EFDC-4C8F-AE8D-41979958C8AC}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{48B60439-EFDC-4C8F-AE8D-41979958C8AC}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{48B60439-EFDC-4C8F-AE8D-41979958C8AC}.Release|Any CPU.Build.0 = Release|Any CPU
+	EndGlobalSection
+	GlobalSection(SolutionProperties) = preSolution
+		HideSolutionNode = FALSE
+	EndGlobalSection
+	GlobalSection(ExtensibilityGlobals) = postSolution
+		SolutionGuid = {1E773F8A-FF66-4974-820B-FCE9032D19AE}
+	EndGlobalSection
+EndGlobal

ru/codes/csharp/hello-algo.csproj

@@ -0,0 +1,21 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <OutputType>Exe</OutputType>
+    <TargetFramework>net8.0</TargetFramework>
+    <RootNamespace>hello_algo</RootNamespace>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.8.0" />
+    <PackageReference Include="NUnit" Version="3.14.0" />
+    <PackageReference Include="NUnit3TestAdapter" Version="4.5.0" />
+    <PackageReference Include="coverlet.collector" Version="6.0.0">
+      <PrivateAssets>all</PrivateAssets>
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+    </PackageReference>
+  </ItemGroup>
+
+</Project>

ru/codes/csharp/utils/ListNode.cs

@@ -0,0 +1,32 @@
+// File: ListNode.cs
+// Created Time: 2022-12-16
+// Author: mingXta (1195669834@qq.com)
+
+namespace hello_algo.utils;
+
+/* Узел связного списка */
+public class ListNode(int x) {
+    public int val = x;
+    public ListNode? next;
+
+    /* Десериализовать массив в связный список */
+    public static ListNode? ArrToLinkedList(int[] arr) {
+        ListNode dum = new(0);
+        ListNode head = dum;
+        foreach (int val in arr) {
+            head.next = new ListNode(val);
+            head = head.next;
+        }
+        return dum.next;
+    }
+
+    public override string? ToString() {
+        List<string> list = [];
+        var head = this;
+        while (head != null) {
+            list.Add(head.val.ToString());
+            head = head.next;
+        }
+        return string.Join("->", list);
+    }
+}

ru/codes/csharp/utils/PrintUtil.cs

@@ -0,0 +1,132 @@
+/**
+* File: PrintUtil.cs
+* Created Time: 2022-12-23
+* Author: haptear (haptear@hotmail.com), krahets (krahets@163.com)
+*/
+
+namespace hello_algo.utils;
+
+public class Trunk(Trunk? prev, string str) {
+    public Trunk? prev = prev;
+    public string str = str;
+};
+
+public static class PrintUtil {
+    /* Вывести список */
+    public static void PrintList<T>(IList<T> list) {
+        Console.WriteLine("[" + string.Join(", ", list) + "]");
+    }
+
+    public static string PrintList<T>(this IEnumerable<T?> list) {
+        return $"[ {string.Join(", ", list.Select(x => x?.ToString() ?? "null"))} ]";
+    }
+
+    /* Вывести матрицу (Array) */
+    public static void PrintMatrix<T>(T[][] matrix) {
+        Console.WriteLine("[");
+        foreach (T[] row in matrix) {
+            Console.WriteLine("  " + string.Join(", ", row) + ",");
+        }
+        Console.WriteLine("]");
+    }
+
+    /* Вывести матрицу (List) */
+    public static void PrintMatrix<T>(List<List<T>> matrix) {
+        Console.WriteLine("[");
+        foreach (List<T> row in matrix) {
+            Console.WriteLine("  " + string.Join(", ", row) + ",");
+        }
+        Console.WriteLine("]");
+    }
+
+    /* Вывести связный список */
+    public static void PrintLinkedList(ListNode? head) {
+        List<string> list = [];
+        while (head != null) {
+            list.Add(head.val.ToString());
+            head = head.next;
+        }
+        Console.Write(string.Join(" -> ", list));
+    }
+
+    /**
+ * Вывести двоичное дерево
+ * Этот вывод дерева заимствован из TECHIE DELIGHT
+ * https://www.techiedelight.com/c-program-print-binary-tree/
+ */
+    public static void PrintTree(TreeNode? root) {
+        PrintTree(root, null, false);
+    }
+
+    /* Вывести двоичное дерево */
+    public static void PrintTree(TreeNode? root, Trunk? prev, bool isRight) {
+        if (root == null) {
+            return;
+        }
+
+        string prev_str = "    ";
+        Trunk trunk = new(prev, prev_str);
+
+        PrintTree(root.right, trunk, true);
+
+        if (prev == null) {
+            trunk.str = "———";
+        } else if (isRight) {
+            trunk.str = "/———";
+            prev_str = "   |";
+        } else {
+            trunk.str = "\\———";
+            prev.str = prev_str;
+        }
+
+        ShowTrunks(trunk);
+        Console.WriteLine(" " + root.val);
+
+        if (prev != null) {
+            prev.str = prev_str;
+        }
+        trunk.str = "   |";
+
+        PrintTree(root.left, trunk, false);
+    }
+
+    public static void ShowTrunks(Trunk? p) {
+        if (p == null) {
+            return;
+        }
+
+        ShowTrunks(p.prev);
+        Console.Write(p.str);
+    }
+
+    /* Вывести хеш-таблицу */
+    public static void PrintHashMap<K, V>(Dictionary<K, V> map) where K : notnull {
+        foreach (var kv in map.Keys) {
+            Console.WriteLine(kv.ToString() + " -> " + map[kv]?.ToString());
+        }
+    }
+
+    /* Вывести кучу */
+    public static void PrintHeap(Queue<int> queue) {
+        Console.Write("Массивное представление кучи:");
+        List<int> list = [.. queue];
+        Console.WriteLine(string.Join(',', list));
+        Console.WriteLine("Древовидное представление кучи:");
+        TreeNode? tree = TreeNode.ListToTree(list.Cast<int?>().ToList());
+        PrintTree(tree);
+    }
+
+    /* Вывести приоритетную очередь */
+    public static void PrintHeap(PriorityQueue<int, int> queue) {
+        var newQueue = new PriorityQueue<int, int>(queue.UnorderedItems, queue.Comparer);
+        Console.Write("Массивное представление кучи:");
+        List<int> list = [];
+        while (newQueue.TryDequeue(out int element, out _)) {
+            list.Add(element);
+        }
+        Console.WriteLine("Древовидное представление кучи:");
+        Console.WriteLine(string.Join(',', list.ToList()));
+        TreeNode? tree = TreeNode.ListToTree(list.Cast<int?>().ToList());
+        PrintTree(tree);
+    }
+}

ru/codes/csharp/utils/TreeNode.cs

@@ -0,0 +1,67 @@
+/**
+ * File: TreeNode.cs
+ * Created Time: 2022-12-23
+ * Author: haptear (haptear@hotmail.com)
+ */
+
+namespace hello_algo.utils;
+
+/* Класс узла двоичного дерева */
+public class TreeNode(int? x) {
+    public int? val = x;    // Значение узла
+    public int height;      // Высота узла
+    public TreeNode? left;  // Ссылка на левый дочерний узел
+    public TreeNode? right; // Ссылка на правый дочерний узел
+
+    // Правила кодирования сериализации см.:
+    // https://www.hello-algo.com/chapter_tree/array_representation_of_tree/
+    // Массивное представление двоичного дерева:
+    // [1, 2, 3, 4, None, 6, 7, 8, 9, None, None, 12, None, None, 15]
+    // Связное представление двоичного дерева:
+    // /——— 15
+    // /——— 7
+    // /——— 3
+    // |    \——— 6
+    // |        \——— 12
+    // ——— 1
+    // \——— 2
+    // |    /——— 9
+    // \——— 4
+    // \——— 8
+
+    /* Десериализовать список в двоичное дерево: рекурсия */
+    static TreeNode? ListToTreeDFS(List<int?> arr, int i) {
+        if (i < 0 || i >= arr.Count || !arr[i].HasValue) {
+            return null;
+        }
+        TreeNode root = new(arr[i]) {
+            left = ListToTreeDFS(arr, 2 * i + 1),
+            right = ListToTreeDFS(arr, 2 * i + 2)
+        };
+        return root;
+    }
+
+    /* Десериализовать список в двоичное дерево */
+    public static TreeNode? ListToTree(List<int?> arr) {
+        return ListToTreeDFS(arr, 0);
+    }
+
+    /* Сериализовать двоичное дерево в список: рекурсия */
+    static void TreeToListDFS(TreeNode? root, int i, List<int?> res) {
+        if (root == null)
+            return;
+        while (i >= res.Count) {
+            res.Add(null);
+        }
+        res[i] = root.val;
+        TreeToListDFS(root.left, 2 * i + 1, res);
+        TreeToListDFS(root.right, 2 * i + 2, res);
+    }
+
+    /* Сериализовать двоичное дерево в список */
+    public static List<int?> TreeToList(TreeNode root) {
+        List<int?> res = [];
+        TreeToListDFS(root, 0, res);
+        return res;
+    }
+}

ru/codes/csharp/utils/Vertex.cs

@@ -0,0 +1,30 @@
+/**
+ * File: Vertex.cs
+ * Created Time: 2023-02-06
+ * Author: zjkung1123 (zjkung1123@gmail.com), krahets (krahets@163.com)
+ */
+
+namespace hello_algo.utils;
+
+/* Класс вершины */
+public class Vertex(int val) {
+    public int val = val;
+
+    /* На вход подается список значений vals, на выходе возвращается список вершин vets */
+    public static Vertex[] ValsToVets(int[] vals) {
+        Vertex[] vets = new Vertex[vals.Length];
+        for (int i = 0; i < vals.Length; i++) {
+            vets[i] = new Vertex(vals[i]);
+        }
+        return vets;
+    }
+
+    /* На вход подается список вершин vets, на выходе возвращается список значений vals */
+    public static List<int> VetsToVals(List<Vertex> vets) {
+        List<int> vals = [];
+        foreach (Vertex vet in vets) {
+            vals.Add(vet.val);
+        }
+        return vals;
+    }
+}