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/dart/build.dart

@@ -0,0 +1,39 @@
+import 'dart:io';
+
+void main() {
+  Directory foldPath = Directory('codes/dart/');
+  List<FileSystemEntity> files = foldPath.listSync();
+  int totalCount = 0;
+  int errorCount = 0;
+  for (var file in files) {
+    if (file.path.endsWith('build.dart')) continue;
+    if (file is File && file.path.endsWith('.dart')) {
+      totalCount++;
+      try {
+        Process.runSync('dart', [file.path]);
+      } catch (e) {
+        errorCount++;
+        print('Error: $e');
+        print('File: ${file.path}');
+      }
+    } else if (file is Directory) {
+      List<FileSystemEntity> subFiles = file.listSync();
+      for (var subFile in subFiles) {
+        if (subFile is File && subFile.path.endsWith('.dart')) {
+          totalCount++;
+          try {
+            Process.runSync('dart', [subFile.path]);
+          } catch (e) {
+            errorCount++;
+            print('Error: $e');
+            print('File: ${file.path}');
+          }
+        }
+      }
+    }
+  }
+
+  print('===== Build Complete =====');
+  print('Total: $totalCount');
+  print('Error: $errorCount');
+}

ru/codes/dart/chapter_array_and_linkedlist/array.dart

@@ -0,0 +1,105 @@
+/**
+ * File: array.dart
+ * Created Time: 2023-01-20
+ * Author: Jefferson (JeffersonHuang77@gmail.com)
+ */
+
+// ignore_for_file: unused_local_variable
+
+import 'dart:math';
+
+/* Случайный доступ к элементу */
+int randomAccess(List<int> nums) {
+  // Случайным образом выбрать число из интервала [0, nums.length)
+  int randomIndex = Random().nextInt(nums.length);
+  // Получить и вернуть случайный элемент
+  int randomNum = nums[randomIndex];
+  return randomNum;
+}
+
+/* Увеличить длину массива */
+List<int> extend(List<int> nums, int enlarge) {
+  // Инициализировать массив увеличенной длины
+  List<int> res = List.filled(nums.length + enlarge, 0);
+  // Скопировать все элементы исходного массива в новый массив
+  for (var i = 0; i < nums.length; i++) {
+    res[i] = nums[i];
+  }
+  // Вернуть новый массив после расширения
+  return res;
+}
+
+/* Вставить элемент _num по индексу index в массив */
+void insert(List<int> nums, int _num, int index) {
+  // Сдвинуть элемент с индексом index и все последующие элементы на одну позицию назад
+  for (var i = nums.length - 1; i > index; i--) {
+    nums[i] = nums[i - 1];
+  }
+  // Присвоить _num элементу по индексу index
+  nums[index] = _num;
+}
+
+/* Удалить элемент по индексу index */
+void remove(List<int> nums, int index) {
+  // Сдвинуть все элементы после индекса index на одну позицию вперед
+  for (var i = index; i < nums.length - 1; i++) {
+    nums[i] = nums[i + 1];
+  }
+}
+
+/* Перебрать элементы массива */
+void traverse(List<int> nums) {
+  int count = 0;
+  // Обход массива по индексам
+  for (var i = 0; i < nums.length; i++) {
+    count += nums[i];
+  }
+  // Непосредственно обходить элементы массива
+  for (int _num in nums) {
+    count += _num;
+  }
+  // Перебрать массив методом forEach
+  nums.forEach((_num) {
+    count += _num;
+  });
+}
+
+/* Найти заданный элемент в массиве */
+int find(List<int> nums, int target) {
+  for (var i = 0; i < nums.length; i++) {
+    if (nums[i] == target) return i;
+  }
+  return -1;
+}
+
+/* Driver Code */
+void main() {
+  /* Инициализация массива */
+  var arr = List.filled(5, 0);
+  print('Массив arr = $arr');
+  List<int> nums = [1, 3, 2, 5, 4];
+  print('Массив nums = $nums');
+
+  /* Случайный доступ */
+  int randomNum = randomAccess(nums);
+  print('Случайный элемент из nums = $randomNum');
+
+  /* Расширение длины */
+  nums = extend(nums, 3);
+  print('После увеличения длины массива до 8 nums = $nums');
+
+  /* Вставка элемента */
+  insert(nums, 6, 3);
+  print('После вставки числа 6 по индексу 3 nums = $nums');
+
+  /* Удаление элемента */
+  remove(nums, 2);
+  print('После удаления элемента по индексу 2 nums = $nums');
+
+  /* Обход массива */
+  traverse(nums);
+
+  /* Поиск элемента */
+  int index = find(nums, 3);
+  print('Поиск элемента 3 в nums: индекс = $index');
+}

ru/codes/dart/chapter_array_and_linkedlist/linked_list.dart

@@ -0,0 +1,83 @@
+/**
+ * File: linked_list.dart
+ * Created Time: 2023-01-23
+ * Author: Jefferson (JeffersonHuang77@gmail.com)
+ */
+
+import '../utils/list_node.dart';
+import '../utils/print_util.dart';
+
+/* Вставить узел 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 (var 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;
+}
+
+/* Driver Code */
+void main() {
+  // Инициализация связного списка
+  // Инициализация всех узлов
+  ListNode n0 = ListNode(1);
+  ListNode n1 = ListNode(3);
+  ListNode n2 = ListNode(2);
+  ListNode n3 = ListNode(5);
+  ListNode n4 = ListNode(4);
+  // Построить ссылки между узлами
+  n0.next = n1;
+  n1.next = n2;
+  n2.next = n3;
+  n3.next = n4;
+
+  print('Исходный связный список');
+  printLinkedList(n0);
+
+  /* Вставка узла */
+  insert(n0, ListNode(0));
+  print('Связный список после вставки узла');
+  printLinkedList(n0);
+
+  /* Удаление узла */
+  remove(n0);
+  print('Связный список после удаления узла');
+  printLinkedList(n0);
+
+  /* Доступ к узлу */
+  ListNode? node = access(n0, 3);
+  print('Значение узла по индексу 3 в связном списке = ${node!.val}');
+
+  /* Поиск узла */
+  int index = find(n0, 2);
+  print('Индекс узла со значением 2 в связном списке = $index');
+}

ru/codes/dart/chapter_array_and_linkedlist/list.dart

@@ -0,0 +1,62 @@
+/**
+ * File: list.dart
+ * Created Time: 2023-01-24
+ * Author: Jefferson (JeffersonHuang77@gmail.com)
+ */
+
+// ignore_for_file: unused_local_variable
+
+/* Driver Code */
+void main() {
+  /* Инициализация списка */
+  List<int> nums = [1, 3, 2, 5, 4];
+  print('Список nums = $nums');
+
+  /* Доступ к элементу */
+  int _num = nums[1];
+  print('Элемент по индексу 1: _num = $_num');
+
+  /* Обновление элемента */
+  nums[1] = 0;
+  print('После обновления элемента по индексу 1 до 0 nums = $nums');
+
+  /* Очистить список */
+  nums.clear();
+  print('После очистки списка nums = $nums');
+
+  /* Добавление элемента в конец */
+  nums.add(1);
+  nums.add(3);
+  nums.add(2);
+  nums.add(5);
+  nums.add(4);
+  print('После добавления элементов nums = $nums');
+
+  /* Вставка элемента в середину */
+  nums.insert(3, 6);
+  print('После вставки числа 6 по индексу 3 nums = $nums');
+
+  /* Удаление элемента */
+  nums.removeAt(3);
+  print('После удаления элемента по индексу 3 nums = $nums');
+
+  /* Обходить список по индексам */
+  int count = 0;
+  for (var i = 0; i < nums.length; i++) {
+    count += nums[i];
+  }
+  /* Непосредственно обходить элементы списка */
+  count = 0;
+  for (var x in nums) {
+    count += x;
+  }
+
+  /* Объединить два списка */
+  List<int> nums1 = [6, 8, 7, 10, 9];
+  nums.addAll(nums1);
+  print('После конкатенации списка nums1 к nums nums = $nums');
+
+  /* Отсортировать список */
+  nums.sort();
+  print('После сортировки списка nums = $nums');
+}

ru/codes/dart/chapter_array_and_linkedlist/my_list.dart

@@ -0,0 +1,132 @@
+/**
+ * File: my_list.dart
+ * Created Time: 2023-02-05
+ * Author: Jefferson (JeffersonHuang77@gmail.com)
+ */
+
+/* Класс списка */
+class MyList {
+  late List<int> _arr; // Массив (для хранения элементов списка)
+  int _capacity = 10; // Вместимость списка
+  int _size = 0; // Длина списка (текущее число элементов)
+  int _extendRatio = 2; // Коэффициент увеличения списка при каждом расширении
+
+  /* Конструктор */
+  MyList() {
+    _arr = List.filled(_capacity, 0);
+  }
+
+  /* Получить длину списка (текущее число элементов) */
+  int size() => _size;
+
+  /* Получить вместимость списка */
+  int capacity() => _capacity;
+
+  /* Доступ к элементу */
+  int get(int index) {
+    if (index >= _size) throw RangeError('индекс выходит за границы');
+    return _arr[index];
+  }
+
+  /* Обновление элемента */
+  void set(int index, int _num) {
+    if (index >= _size) throw RangeError('индекс выходит за границы');
+    _arr[index] = _num;
+  }
+
+  /* Добавление элемента в конец */
+  void add(int _num) {
+    // При превышении вместимости по числу элементов запускается расширение
+    if (_size == _capacity) extendCapacity();
+    _arr[_size] = _num;
+    // Обновить число элементов
+    _size++;
+  }
+
+  /* Вставка элемента в середину */
+  void insert(int index, int _num) {
+    if (index >= _size) throw RangeError('индекс выходит за границы');
+    // При превышении вместимости по числу элементов запускается расширение
+    if (_size == _capacity) extendCapacity();
+    // Сдвинуть элемент с индексом index и все следующие элементы на одну позицию назад
+    for (var j = _size - 1; j >= index; j--) {
+      _arr[j + 1] = _arr[j];
+    }
+    _arr[index] = _num;
+    // Обновить число элементов
+    _size++;
+  }
+
+  /* Удаление элемента */
+  int remove(int index) {
+    if (index >= _size) throw RangeError('индекс выходит за границы');
+    int _num = _arr[index];
+    // Сдвинуть все элементы после индекса index на одну позицию вперед
+    for (var j = index; j < _size - 1; j++) {
+      _arr[j] = _arr[j + 1];
+    }
+    // Обновить число элементов
+    _size--;
+    // Вернуть удаленный элемент
+    return _num;
+  }
+
+  /* Расширение списка */
+  void extendCapacity() {
+    // Создать новый массив длиной в _extendRatio раз больше исходного массива
+    final _newNums = List.filled(_capacity * _extendRatio, 0);
+    // Скопировать исходный массив в новый массив
+    List.copyRange(_newNums, 0, _arr);
+    // Обновить ссылку на _arr
+    _arr = _newNums;
+    // Обновить вместимость списка
+    _capacity = _arr.length;
+  }
+
+  /* Преобразовать список в массив */
+  List<int> toArray() {
+    List<int> arr = [];
+    for (var i = 0; i < _size; i++) {
+      arr.add(get(i));
+    }
+    return arr;
+  }
+}
+
+/* Driver Code */
+void main() {
+  /* Инициализация списка */
+  MyList nums = MyList();
+  /* Добавление элемента в конец */
+  nums.add(1);
+  nums.add(3);
+  nums.add(2);
+  nums.add(5);
+  nums.add(4);
+  print(
+      'Список nums = ${nums.toArray()}, вместимость = ${nums.capacity()}, длина = ${nums.size()}');
+
+  /* Вставка элемента в середину */
+  nums.insert(3, 6);
+  print('После вставки числа 6 по индексу 3 nums = ${nums.toArray()}');
+
+  /* Удаление элемента */
+  nums.remove(3);
+  print('После удаления элемента по индексу 3 nums = ${nums.toArray()}');
+
+  /* Доступ к элементу */
+  int _num = nums.get(1);
+  print('Элемент по индексу 1: _num = $_num');
+
+  /* Обновление элемента */
+  nums.set(1, 0);
+  print('После обновления элемента по индексу 1 до 0 nums = ${nums.toArray()}');
+
+  /* Проверка механизма расширения */
+  for (var i = 0; i < 10; i++) {
+    // При i = 5 длина списка превысит его вместимость, и в этот момент сработает механизм расширения
+    nums.add(i);
+  }
+  print(
+      'Список nums после увеличения вместимости = ${nums.toArray()}, вместимость = ${nums.capacity()}, длина = ${nums.size()}');
+}

ru/codes/dart/chapter_backtracking/n_queens.dart

@@ -0,0 +1,75 @@
+/**
+ * File: n_queens.dart
+ * Created Time: 2023-08-10
+ * Author: liuyuxin (gvenusleo@gmail.com)
+ */
+
+/* Алгоритм бэктрекинга: n ферзей */
+void backtrack(
+  int row,
+  int n,
+  List<List<String>> state,
+  List<List<List<String>>> res,
+  List<bool> cols,
+  List<bool> diags1,
+  List<bool> diags2,
+) {
+  // Когда все строки уже обработаны, записать решение
+  if (row == n) {
+    List<List<String>> copyState = [];
+    for (List<String> sRow in state) {
+      copyState.add(List.from(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] = true;
+      diags1[diag1] = true;
+      diags2[diag2] = true;
+      // Перейти к размещению следующей строки
+      backtrack(row + 1, n, state, res, cols, diags1, diags2);
+      // Откат: восстановить эту клетку как пустую
+      state[row][col] = "#";
+      cols[col] = false;
+      diags1[diag1] = false;
+      diags2[diag2] = false;
+    }
+  }
+}
+
+/* Решить задачу о n ферзях */
+List<List<List<String>>> nQueens(int n) {
+  // Инициализировать доску размера n*n, где 'Q' обозначает ферзя, а '#' — пустую клетку
+  List<List<String>> state = List.generate(n, (index) => List.filled(n, "#"));
+  List<bool> cols = List.filled(n, false); // Отмечать, есть ли ферзь в столбце
+  List<bool> diags1 = List.filled(2 * n - 1, false); // Отмечать наличие ферзя на главной диагонали
+  List<bool> diags2 = List.filled(2 * n - 1, false); // Отмечать наличие ферзя на побочной диагонали
+  List<List<List<String>>> res = [];
+
+  backtrack(0, n, state, res, cols, diags1, diags2);
+
+  return res;
+}
+
+/* Driver Code */
+void main() {
+  int n = 4;
+  List<List<List<String>>> res = nQueens(n);
+  print("Размер входной доски = $n");
+  print("Количество способов расстановки ферзей: ${res.length}");
+  for (List<List<String>> state in res) {
+    print("--------------------");
+    for (List<String> row in state) {
+      print(row);
+    }
+  }
+}

ru/codes/dart/chapter_backtracking/permutations_i.dart

@@ -0,0 +1,51 @@
+/**
+ * File: permutations_i.dart
+ * Created Time: 2023-08-10
+ * Author: liuyuxin (gvenusleo@gmail.com)
+ */
+
+/* Алгоритм бэктрекинга: все перестановки I */
+void backtrack(
+  List<int> state,
+  List<int> choices,
+  List<bool> selected,
+  List<List<int>> res,
+) {
+  // Когда длина состояния равна числу элементов, записать решение
+  if (state.length == choices.length) {
+    res.add(List.from(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.removeLast();
+    }
+  }
+}
+
+/* Все перестановки I */
+List<List<int>> permutationsI(List<int> nums) {
+  List<List<int>> res = [];
+  backtrack([], nums, List.filled(nums.length, false), res);
+  return res;
+}
+
+/* Driver Code */
+void main() {
+  List<int> nums = [1, 2, 3];
+
+  List<List<int>> res = permutationsI(nums);
+
+  print("Входной массив nums = $nums");
+  print("Все перестановки res = $res");
+}

ru/codes/dart/chapter_backtracking/permutations_ii.dart

@@ -0,0 +1,53 @@
+/**
+ * File: permutations_ii.dart
+ * Created Time: 2023-08-10
+ * Author: liuyuxin (gvenusleo@gmail.com)
+ */
+
+/* Алгоритм бэктрекинга: все перестановки II */
+void backtrack(
+  List<int> state,
+  List<int> choices,
+  List<bool> selected,
+  List<List<int>> res,
+) {
+  // Когда длина состояния равна числу элементов, записать решение
+  if (state.length == choices.length) {
+    res.add(List.from(state));
+    return;
+  }
+  // Перебор всех вариантов выбора
+  Set<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.removeLast();
+    }
+  }
+}
+
+/* Все перестановки II */
+List<List<int>> permutationsII(List<int> nums) {
+  List<List<int>> res = [];
+  backtrack([], nums, List.filled(nums.length, false), res);
+  return res;
+}
+
+/* Driver Code */
+void main() {
+  List<int> nums = [1, 2, 2];
+
+  List<List<int>> res = permutationsII(nums);
+
+  print("Входной массив nums = $nums");
+  print("Все перестановки res = $res");
+}

ru/codes/dart/chapter_backtracking/preorder_traversal_i_compact.dart

@@ -0,0 +1,35 @@
+/**
+ * File: preorder_traversal_i_compact.dart
+ * Created Time: 2023-08-10
+ * Author: liuyuxin (gvenusleo@gmail.com)
+ */
+
+import '../utils/print_util.dart';
+import '../utils/tree_node.dart';
+
+/* Предварительный обход: пример 1 */
+void preOrder(TreeNode? root, List<TreeNode> res) {
+  if (root == null) {
+    return;
+  }
+  if (root.val == 7) {
+    // Записать решение
+    res.add(root);
+  }
+  preOrder(root.left, res);
+  preOrder(root.right, res);
+}
+
+/* Driver Code */
+void main() {
+  TreeNode? root = listToTree([1, 7, 3, 4, 5, 6, 7]);
+  print("\nИнициализация двоичного дерева");
+  printTree(root);
+
+  // Предварительный обход
+  List<TreeNode> res = [];
+  preOrder(root, res);
+
+  print("\nВсе узлы со значением 7");
+  print(List.generate(res.length, (i) => res[i].val));
+}

ru/codes/dart/chapter_backtracking/preorder_traversal_ii_compact.dart

@@ -0,0 +1,47 @@
+/**
+ * File: preorder_traversal_ii_compact.dart
+ * Created Time: 2023-08-10
+ * Author: liuyuxin (gvenusleo@gmail.com)
+ */
+
+import '../utils/print_util.dart';
+import '../utils/tree_node.dart';
+
+/* Предварительный обход: пример 2 */
+void preOrder(
+  TreeNode? root,
+  List<TreeNode> path,
+  List<List<TreeNode>> res,
+) {
+  if (root == null) {
+    return;
+  }
+
+  // Попытка
+  path.add(root);
+  if (root.val == 7) {
+    // Записать решение
+    res.add(List.from(path));
+  }
+  preOrder(root.left, path, res);
+  preOrder(root.right, path, res);
+  // Откат
+  path.removeLast();
+}
+
+/* Driver Code */
+void main() {
+  TreeNode? root = listToTree([1, 7, 3, 4, 5, 6, 7]);
+  print("\nИнициализация двоичного дерева");
+  printTree(root);
+
+  // Предварительный обход
+  List<TreeNode> path = [];
+  List<List<TreeNode>> res = [];
+  preOrder(root, path, res);
+
+  print("\nВсе пути от корня к узлу 7");
+  for (List<TreeNode> vals in res) {
+    print(List.generate(vals.length, (i) => vals[i].val));
+  }
+}

ru/codes/dart/chapter_backtracking/preorder_traversal_iii_compact.dart

@@ -0,0 +1,47 @@
+/**
+ * File: preorder_traversal_iii_compact.dart
+ * Created Time: 2023-08-10
+ * Author: liuyuxin (gvenusleo@gmail.com)
+ */
+
+import '../utils/print_util.dart';
+import '../utils/tree_node.dart';
+
+/* Предварительный обход: пример 3 */
+void preOrder(
+  TreeNode? root,
+  List<TreeNode> path,
+  List<List<TreeNode>> res,
+) {
+  if (root == null || root.val == 3) {
+    return;
+  }
+
+  // Попытка
+  path.add(root);
+  if (root.val == 7) {
+    // Записать решение
+    res.add(List.from(path));
+  }
+  preOrder(root.left, path, res);
+  preOrder(root.right, path, res);
+  // Откат
+  path.removeLast();
+}
+
+/* Driver Code */
+void main() {
+  TreeNode? root = listToTree([1, 7, 3, 4, 5, 6, 7]);
+  print("\nИнициализация двоичного дерева");
+  printTree(root);
+
+  // Предварительный обход
+  List<TreeNode> path = [];
+  List<List<TreeNode>> res = [];
+  preOrder(root, path, res);
+
+  print("\nВсе пути от корня к узлу 7");
+  for (List<TreeNode> vals in res) {
+    print(List.generate(vals.length, (i) => vals[i].val));
+  }
+}

ru/codes/dart/chapter_backtracking/preorder_traversal_iii_template.dart

@@ -0,0 +1,73 @@
+/**
+ * File: preorder_traversal_iii_template.dart
+ * Created Time: 2023-08-10
+ * Author: liuyuxin (gvenusleo@gmail.com)
+ */
+
+import '../utils/print_util.dart';
+import '../utils/tree_node.dart';
+
+/* Проверить, является ли текущее состояние решением */
+bool isSolution(List<TreeNode> state) {
+  return state.isNotEmpty && state.last.val == 7;
+}
+
+/* Записать решение */
+void recordSolution(List<TreeNode> state, List<List<TreeNode>> res) {
+  res.add(List.from(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.removeLast();
+}
+
+/* Алгоритм бэктрекинга: пример 3 */
+void backtrack(
+  List<TreeNode> state,
+  List<TreeNode?> choices,
+  List<List<TreeNode>> res,
+) {
+  // Проверить, является ли текущее состояние решением
+  if (isSolution(state)) {
+    // Записать решение
+    recordSolution(state, res);
+  }
+  // Перебор всех вариантов выбора
+  for (TreeNode? choice in choices) {
+    // Отсечение: проверить допустимость выбора
+    if (isValid(state, choice)) {
+      // Попытка: сделать выбор и обновить состояние
+      makeChoice(state, choice);
+      // Перейти к следующему выбору
+      backtrack(state, [choice!.left, choice.right], res);
+      // Откат: отменить выбор и восстановить предыдущее состояние
+      undoChoice(state, choice);
+    }
+  }
+}
+
+/* Driver Code */
+void main() {
+  TreeNode? root = listToTree([1, 7, 3, 4, 5, 6, 7]);
+  print("\nИнициализация двоичного дерева");
+  printTree(root);
+
+  // Алгоритм бэктрекинга
+  List<List<TreeNode>> res = [];
+  backtrack([], [root!], res);
+  print("\nВсе пути от корня к узлу 7, в которых путь не содержит узлов со значением 3");
+  for (List<TreeNode> path in res) {
+    print(List.from(path.map((e) => e.val)));
+  }
+}

ru/codes/dart/chapter_backtracking/subset_sum_i.dart

@@ -0,0 +1,56 @@
+/**
+ * File: subset_sum_i.dart
+ * Created Time: 2023-08-10
+ * Author: liuyuxin (gvenusleo@gmail.com)
+ */
+
+/* Алгоритм бэктрекинга: сумма подмножеств I */
+void backtrack(
+  List<int> state,
+  int target,
+  List<int> choices,
+  int start,
+  List<List<int>> res,
+) {
+  // Если сумма подмножества равна target, записать решение
+  if (target == 0) {
+    res.add(List.from(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.removeLast();
+  }
+}
+
+/* Решить задачу суммы подмножеств I */
+List<List<int>> subsetSumI(List<int> nums, int target) {
+  List<int> state = []; // Состояние (подмножество)
+  nums.sort(); // Отсортировать nums
+  int start = 0; // Стартовая вершина обхода
+  List<List<int>> res = []; // Список результатов (список подмножеств)
+  backtrack(state, target, nums, start, res);
+  return res;
+}
+
+/* Driver Code */
+void main() {
+  List<int> nums = [3, 4, 5];
+  int target = 9;
+
+  List<List<int>> res = subsetSumI(nums, target);
+
+  print("Входной массив nums = $nums, target = $target");
+  print("Все подмножества с суммой $target: res = $res");
+}

ru/codes/dart/chapter_backtracking/subset_sum_i_naive.dart

@@ -0,0 +1,54 @@
+/**
+ * File: subset_sum_i_naive.dart
+ * Created Time: 2023-08-10
+ * Author: liuyuxin (gvenusleo@gmail.com)
+ */
+
+/* Алгоритм бэктрекинга: сумма подмножеств I */
+void backtrack(
+  List<int> state,
+  int target,
+  int total,
+  List<int> choices,
+  List<List<int>> res,
+) {
+  // Если сумма подмножества равна target, записать решение
+  if (total == target) {
+    res.add(List.from(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.removeLast();
+  }
+}
+
+/* Решить задачу суммы подмножеств I (с повторяющимися подмножествами) */
+List<List<int>> subsetSumINaive(List<int> nums, int target) {
+  List<int> state = []; // Состояние (подмножество)
+  int total = 0; // Сумма элементов
+  List<List<int>> res = []; // Список результатов (список подмножеств)
+  backtrack(state, target, total, nums, res);
+  return res;
+}
+
+/* Driver Code */
+void main() {
+  List<int> nums = [3, 4, 5];
+  int target = 9;
+
+  List<List<int>> res = subsetSumINaive(nums, target);
+
+  print("Входной массив nums = $nums, target = $target");
+  print("Все подмножества с суммой $target: res = $res");
+  print("Обратите внимание: результат этого метода содержит повторяющиеся множества");
+}

ru/codes/dart/chapter_backtracking/subset_sum_ii.dart

@@ -0,0 +1,61 @@
+/**
+ * File: subset_sum_ii.dart
+ * Created Time: 2023-08-10
+ * Author: liuyuxin (gvenusleo@gmail.com)
+ */
+
+/* Алгоритм бэктрекинга: сумма подмножеств II */
+void backtrack(
+  List<int> state,
+  int target,
+  List<int> choices,
+  int start,
+  List<List<int>> res,
+) {
+  // Если сумма подмножества равна target, записать решение
+  if (target == 0) {
+    res.add(List.from(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.removeLast();
+  }
+}
+
+/* Решить задачу суммы подмножеств II */
+List<List<int>> subsetSumII(List<int> nums, int target) {
+  List<int> state = []; // Состояние (подмножество)
+  nums.sort(); // Отсортировать nums
+  int start = 0; // Стартовая вершина обхода
+  List<List<int>> res = []; // Список результатов (список подмножеств)
+  backtrack(state, target, nums, start, res);
+  return res;
+}
+
+/* Driver Code */
+void main() {
+  List<int> nums = [4, 4, 5];
+  int target = 9;
+
+  List<List<int>> res = subsetSumII(nums, target);
+
+  print("Входной массив nums = $nums, target = $target");
+  print("Все подмножества с суммой $target: res = $res");
+}

ru/codes/dart/chapter_computational_complexity/iteration.dart

@@ -0,0 +1,72 @@
+/**
+ * File: iteration.dart
+ * Created Time: 2023-08-27
+ * Author: liuyuxin (gvenusleo@gmail.com)
+ */
+
+/* Цикл 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++; // Обновить условную переменную
+  }
+  return res;
+}
+
+/* Цикл while (двойное обновление) */
+int whileLoopII(int n) {
+  int res = 0;
+  int i = 1; // Инициализация условной переменной
+  // Циклическое суммирование 1, 4, 10, ...
+  while (i <= n) {
+    res += i;
+    // Обновить условную переменную
+    i++;
+    i *= 2;
+  }
+  return res;
+}
+
+/* Двойной цикл for */
+String nestedForLoop(int n) {
+  String res = "";
+  // Цикл по 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 += "($i, $j), ";
+    }
+  }
+  return res;
+}
+
+/* Driver Code */
+void main() {
+  int n = 5;
+  int res;
+
+  res = forLoop(n);
+  print("\nРезультат суммирования в цикле for res = $res");
+
+  res = whileLoop(n);
+  print("\nРезультат суммирования в цикле while res = $res");
+
+  res = whileLoopII(n);
+  print("\nРезультат суммирования в цикле while (двойное обновление) res = $res");
+
+  String resStr = nestedForLoop(n);
+  print("\nРезультат двойного цикла for $resStr");
+}

ru/codes/dart/chapter_computational_complexity/recursion.dart

@@ -0,0 +1,70 @@
+/**
+ * File: recursion.dart
+ * Created Time: 2023-08-27
+ * Author: liuyuxin (gvenusleo@gmail.com)
+ */
+
+/* Рекурсия */
+int recur(int n) {
+  // Условие завершения
+  if (n == 1) return 1;
+  // Рекурсия: рекурсивный вызов
+  int res = recur(n - 1);
+  // Возврат: вернуть результат
+  return n + res;
+}
+
+/* Имитация рекурсии итерацией */
+int forLoopRecur(int n) {
+  // Использовать явный стек для имитации системного стека вызовов
+  List<int> stack = [];
+  int res = 0;
+  // Рекурсия: рекурсивный вызов
+  for (int i = n; i > 0; i--) {
+    // Имитировать «рекурсию» с помощью операции помещения в стек
+    stack.add(i);
+  }
+  // Возврат: вернуть результат
+  while (!stack.isEmpty) {
+    // Имитировать «возврат» с помощью операции извлечения из стека
+    res += stack.removeLast();
+  }
+  // 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 */
+void main() {
+  int n = 5;
+  int res;
+
+  res = recur(n);
+  print("\nРезультат суммирования в рекурсивной функции res = $res");
+
+  res = tailRecur(n, 0);
+  print("\nРезультат суммирования в хвостовой рекурсии res = $res");
+
+  res = forLoopRecur(n);
+  print("\nРезультат суммирования при имитации рекурсии итерацией res = $res");
+
+  res = fib(n);
+  print("\nЧлен последовательности Фибоначчи с номером $n = $res");
+}

ru/codes/dart/chapter_computational_complexity/space_complexity.dart

@@ -0,0 +1,106 @@
+/**
+ * File: space_complexity.dart
+ * Created Time: 2023-2-12
+ * Author: Jefferson (JeffersonHuang77@gmail.com)
+ */
+
+// ignore_for_file: unused_local_variable
+
+import 'dart:collection';
+import '../utils/list_node.dart';
+import '../utils/print_util.dart';
+import '../utils/tree_node.dart';
+
+/* Функция */
+int function() {
+  // Выполнить некоторые операции
+  return 0;
+}
+
+/* Постоянная сложность */
+void constant(int n) {
+  // Константы, переменные и объекты занимают O(1) памяти
+  final int a = 0;
+  int b = 0;
+  List<int> nums = List.filled(10000, 0);
+  ListNode node = ListNode(0);
+  // Переменные в цикле занимают O(1) памяти
+  for (var i = 0; i < n; i++) {
+    int c = 0;
+  }
+  // Функции в цикле занимают O(1) памяти
+  for (var i = 0; i < n; i++) {
+    function();
+  }
+}
+
+/* Линейная сложность */
+void linear(int n) {
+  // Массив длины n занимает O(n) памяти
+  List<int> nums = List.filled(n, 0);
+  // Список длины n занимает O(n) памяти
+  List<ListNode> nodes = [];
+  for (var i = 0; i < n; i++) {
+    nodes.add(ListNode(i));
+  }
+  // Хеш-таблица длины n занимает O(n) памяти
+  Map<int, String> map = HashMap();
+  for (var i = 0; i < n; i++) {
+    map.putIfAbsent(i, () => i.toString());
+  }
+}
+
+/* Линейная сложность (рекурсивная реализация) */
+void linearRecur(int n) {
+  print('Рекурсия n = $n');
+  if (n == 1) return;
+  linearRecur(n - 1);
+}
+
+/* Квадратичная сложность */
+void quadratic(int n) {
+  // Матрица занимает O(n^2) памяти
+  List<List<int>> numMatrix = List.generate(n, (_) => List.filled(n, 0));
+  // Двумерный список занимает O(n^2) памяти
+  List<List<int>> numList = [];
+  for (var 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;
+  List<int> nums = List.filled(n, 0);
+  print('В рекурсии n = $n длина nums = ${nums.length}');
+  return quadraticRecur(n - 1);
+}
+
+/* Экспоненциальная сложность (построение полного двоичного дерева) */
+TreeNode? buildTree(int n) {
+  if (n == 0) return null;
+  TreeNode root = TreeNode(0);
+  root.left = buildTree(n - 1);
+  root.right = buildTree(n - 1);
+  return root;
+}
+
+/* Driver Code */
+void main() {
+  int n = 5;
+  // Постоянная сложность
+  constant(n);
+  // Линейная сложность
+  linear(n);
+  linearRecur(n);
+  // Квадратичная сложность
+  quadratic(n);
+  quadraticRecur(n);
+  // Экспоненциальная сложность
+  TreeNode? root = buildTree(n);
+  printTree(root);
+}

ru/codes/dart/chapter_computational_complexity/time_complexity.dart

@@ -0,0 +1,165 @@
+/**
+ * File: time_complexity.dart
+ * Created Time: 2023-02-12
+ * Author: Jefferson (JeffersonHuang77@gmail.com)
+ */
+
+// ignore_for_file: unused_local_variable
+
+/* Постоянная сложность */
+int constant(int n) {
+  int count = 0;
+  int size = 100000;
+  for (var i = 0; i < size; i++) {
+    count++;
+  }
+  return count;
+}
+
+/* Линейная сложность */
+int linear(int n) {
+  int count = 0;
+  for (var i = 0; i < n; i++) {
+    count++;
+  }
+  return count;
+}
+
+/* Линейная сложность (обход массива) */
+int arrayTraversal(List<int> nums) {
+  int count = 0;
+  // Число итераций пропорционально длине массива
+  for (var _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(List<int> nums) {
+  int count = 0; // Счетчик
+  // Внешний цикл: неотсортированный диапазон [0, i]
+  for (var i = nums.length - 1; i > 0; i--) {
+    // Внутренний цикл: переместить максимальный элемент неотсортированного диапазона [0, i] в его правый конец
+    for (var j = 0; j < i; j++) {
+      if (nums[j] > nums[j + 1]) {
+        // Поменять местами nums[j] и nums[j + 1]
+        int tmp = nums[j];
+        nums[j] = nums[j + 1];
+        nums[j + 1] = tmp;
+        count += 3; // Обмен элементов включает 3 элементарные операции
+      }
+    }
+  }
+  return count;
+}
+
+/* Экспоненциальная сложность (итеративная реализация) */
+int exponential(int n) {
+  int count = 0, base = 1;
+  // На каждом шаге клетка делится надвое, образуя последовательность 1, 2, 4, 8, ..., 2^(n-1)
+  for (var i = 0; i < n; i++) {
+    for (var j = 0; j < base; j++) {
+      count++;
+    }
+    base *= 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 = 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 (var i = 0; i < n; i++) {
+    count++;
+  }
+  return count;
+}
+
+/* Факториальная сложность (рекурсивная реализация) */
+int factorialRecur(int n) {
+  if (n == 0) return 1;
+  int count = 0;
+  // Из одного получается n
+  for (var i = 0; i < n; i++) {
+    count += factorialRecur(n - 1);
+  }
+  return count;
+}
+
+/* Driver Code */
+void main() {
+  // Можно изменить n и запустить программу, чтобы увидеть, как меняется число операций при разных сложностях
+  int n = 8;
+  print('Размер входных данных n = $n');
+
+  int count = constant(n);
+  print('Число операций константной сложности = $count');
+
+  count = linear(n);
+  print('Число операций линейной сложности = $count');
+
+  count = arrayTraversal(List.filled(n, 0));
+  print('Число операций линейной сложности (обход массива) = $count');
+
+  count = quadratic(n);
+  print('Число операций квадратичной сложности = $count');
+  final nums = List.filled(n, 0);
+  for (int i = 0; i < n; i++) {
+    nums[i] = n - i; // [n,n-1,...,2,1]
+  }
+  count = bubbleSort(nums);
+  print('Число операций квадратичной сложности (пузырьковая сортировка) = $count');
+
+  count = exponential(n);
+  print('Число операций экспоненциальной сложности (итеративная реализация) = $count');
+  count = expRecur(n);
+  print('Число операций экспоненциальной сложности (рекурсивная реализация) = $count');
+
+  count = logarithmic(n);
+  print('Число операций логарифмической сложности (итеративная реализация) = $count');
+  count = logRecur(n);
+  print('Число операций логарифмической сложности (рекурсивная реализация) = $count');
+
+  count = linearLogRecur(n);
+  print('Число операций линейно-логарифмической сложности (рекурсивная реализация) = $count');
+
+  count = factorialRecur(n);
+  print('Число операций факториальной сложности (рекурсивная реализация) = $count');
+}

ru/codes/dart/chapter_computational_complexity/worst_best_time_complexity.dart

@@ -0,0 +1,40 @@
+/**
+ * File: worst_best_time_complexity.dart
+ * Created Time: 2023-02-12
+ * Author: Jefferson (JeffersonHuang77@gmail.com)
+ */
+
+/* Создать массив с элементами { 1, 2, ..., n } в случайном порядке */
+List<int> randomNumbers(int n) {
+  final nums = List.filled(n, 0);
+  // Создать массив nums = { 1, 2, 3, ..., n }
+  for (var i = 0; i < n; i++) {
+    nums[i] = i + 1;
+  }
+  // Случайно перемешать элементы массива
+  nums.shuffle();
+
+  return nums;
+}
+
+/* Найти индекс числа 1 в массиве nums */
+int findOne(List<int> nums) {
+  for (var i = 0; i < nums.length; i++) {
+    // Когда элемент 1 находится в начале массива, достигается лучшая временная сложность O(1)
+    // Когда элемент 1 находится в конце массива, достигается худшая временная сложность O(n)
+    if (nums[i] == 1) return i;
+  }
+
+  return -1;
+}
+
+/* Driver Code */
+void main() {
+  for (var i = 0; i < 10; i++) {
+    int n = 100;
+    final nums = randomNumbers(n);
+    int index = findOne(nums);
+    print('\nМассив [1, 2, ..., n] после перемешивания = $nums');
+    print('Индекс числа 1 = $index');
+  }
+}

ru/codes/dart/chapter_divide_and_conquer/binary_search_recur.dart

@@ -0,0 +1,42 @@
+/**
+ * File: binary_search_recur.dart
+ * Created Time: 2023-08-10
+ * Author: liuyuxin (gvenusleo@gmail.com)
+ */
+
+/* Бинарный поиск: задача f(i, j) */
+int dfs(List<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(List<int> nums, int target) {
+  int n = nums.length;
+  // Решить задачу f(0, n-1)
+  return dfs(nums, target, 0, n - 1);
+}
+
+/* Driver Code */
+void main() {
+  int target = 6;
+  List<int> nums = [1, 3, 6, 8, 12, 15, 23, 26, 31, 35];
+
+  // Бинарный поиск (двусторонне замкнутый интервал)
+  int index = binarySearch(nums, target);
+  print("Индекс целевого элемента 6 = $index");
+}

ru/codes/dart/chapter_divide_and_conquer/build_tree.dart

@@ -0,0 +1,55 @@
+/**
+ * File: build_tree.dart
+ * Created Time: 2023-08-10
+ * Author: liuyuxin (gvenusleo@gmail.com)
+ */
+
+import '../utils/print_util.dart';
+import '../utils/tree_node.dart';
+
+/* Построить двоичное дерево: разделяй и властвуй */
+TreeNode? dfs(
+  List<int> preorder,
+  Map<int, int> inorderMap,
+  int i,
+  int l,
+  int r,
+) {
+  // Завершить при пустом диапазоне поддерева
+  if (r - l < 0) {
+    return null;
+  }
+  // Инициализировать корневой узел
+  TreeNode? root = TreeNode(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(List<int> preorder, List<int> inorder) {
+  // Инициализировать хеш-таблицу для хранения соответствия элементов inorder их индексам
+  Map<int, int> inorderMap = {};
+  for (int i = 0; i < inorder.length; i++) {
+    inorderMap[inorder[i]] = i;
+  }
+  TreeNode? root = dfs(preorder, inorderMap, 0, 0, inorder.length - 1);
+  return root;
+}
+
+/* Driver Code */
+void main() {
+  List<int> preorder = [3, 9, 2, 1, 7];
+  List<int> inorder = [9, 3, 1, 2, 7];
+  print("Предварительный обход = $preorder");
+  print("Симметричный обход = $inorder");
+
+  TreeNode? root = buildTree(preorder, inorder);
+  print("Построенное двоичное дерево:");
+  printTree(root!);
+}

ru/codes/dart/chapter_divide_and_conquer/hanota.dart

@@ -0,0 +1,54 @@
+/**
+ * File: hanota.dart
+ * Created Time: 2023-08-10
+ * Author: liuyuxin (gvenusleo@gmail.com)
+ */
+
+/* Переместить один диск */
+void move(List<int> src, List<int> tar) {
+  // Снять диск с вершины src
+  int pan = src.removeLast();
+  // Положить диск на вершину 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.length;
+  // Переместить верхние n дисков из A в C с помощью B
+  dfs(n, A, B, C);
+}
+
+/* Driver Code */
+void main() {
+  // Хвост списка соответствует вершине столбца
+  List<int> A = [5, 4, 3, 2, 1];
+  List<int> B = [];
+  List<int> C = [];
+  print("Исходное состояние:");
+  print("A = $A");
+  print("B = $B");
+  print("C = $C");
+
+  solveHanota(A, B, C);
+
+  print("После завершения перемещения дисков:");
+  print("A = $A");
+  print("B = $B");
+  print("C = $C");
+}

ru/codes/dart/chapter_dynamic_programming/climbing_stairs_backtrack.dart

@@ -0,0 +1,39 @@
+/**
+ * File: climbing_stairs_backtrack.dart
+ * Created Time: 2023-08-11
+ * Author: liuyuxin (gvenusleo@gmail.com)
+ */
+
+/* Бэктрекинг */
+void backtrack(List<int> choices, int state, int n, List<int> res) {
+  // Когда подъем достигает n-й ступени, число вариантов увеличивается на 1
+  if (state == n) {
+    res[0]++;
+  }
+  // Перебор всех вариантов выбора
+  for (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 = [];
+  res.add(0); // Использовать res[0] для хранения числа решений
+  backtrack(choices, state, n, res);
+  return res[0];
+}
+
+/* Driver Code */
+void main() {
+  int n = 9;
+
+  int res = climbingStairsBacktrack(n);
+  print("Количество способов подняться по лестнице из $n ступеней = $res");
+}

ru/codes/dart/chapter_dynamic_programming/climbing_stairs_constraint_dp.dart

@@ -0,0 +1,33 @@
+/**
+ * File: climbing_stairs_constraint_dp.dart
+ * Created Time: 2023-08-11
+ * Author: liuyuxin (gvenusleo@gmail.com)
+ */
+
+/* Подъем по лестнице с ограничениями: динамическое программирование */
+int climbingStairsConstraintDP(int n) {
+  if (n == 1 || n == 2) {
+    return 1;
+  }
+  // Инициализация таблицы dp для хранения решений подзадач
+  List<List<int>> dp = List.generate(n + 1, (index) => List.filled(3, 0));
+  // Начальное состояние: заранее задать решения наименьших подзадач
+  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];
+}
+
+/* Driver Code */
+void main() {
+  int n = 9;
+
+  int res = climbingStairsConstraintDP(n);
+  print("Количество способов подняться по лестнице из $n ступеней = $res");
+}

ru/codes/dart/chapter_dynamic_programming/climbing_stairs_dfs.dart

@@ -0,0 +1,27 @@
+/**
+ * File: climbing_stairs_dfs.dart
+ * Created Time: 2023-08-11
+ * Author: liuyuxin (gvenusleo@gmail.com)
+ */
+
+/* Поиск */
+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);
+}
+
+/* Driver Code */
+void main() {
+  int n = 9;
+
+  int res = climbingStairsDFS(n);
+  print("Количество способов подняться по лестнице из $n ступеней = $res");
+}

ru/codes/dart/chapter_dynamic_programming/climbing_stairs_dfs_mem.dart

@@ -0,0 +1,33 @@
+/**
+ * File: climbing_stairs_dfs_mem.dart
+ * Created Time: 2023-08-11
+ * Author: liuyuxin (gvenusleo@gmail.com)
+ */
+
+/* Поиск с мемоизацией */
+int dfs(int i, List<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 означает отсутствие записи
+  List<int> mem = List.filled(n + 1, -1);
+  return dfs(n, mem);
+}
+
+/* Driver Code */
+void main() {
+  int n = 9;
+
+  int res = climbingStairsDFSMem(n);
+  print("Количество способов подняться по лестнице из $n ступеней = $res");
+}

ru/codes/dart/chapter_dynamic_programming/climbing_stairs_dp.dart

@@ -0,0 +1,43 @@
+/**
+ * File: climbing_stairs_dp.dart
+ * Created Time: 2023-08-11
+ * Author: liuyuxin (gvenusleo@gmail.com)
+ */
+
+/* Подъем по лестнице: динамическое программирование */
+int climbingStairsDP(int n) {
+  if (n == 1 || n == 2) return n;
+  // Инициализация таблицы dp для хранения решений подзадач
+  List<int> dp = List.filled(n + 1, 0);
+  // Начальное состояние: заранее задать решения наименьших подзадач
+  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;
+}
+
+/* Driver Code */
+void main() {
+  int n = 9;
+
+  int res = climbingStairsDP(n);
+  print("Количество способов подняться по лестнице из $n ступеней = $res");
+
+  res = climbingStairsDPComp(n);
+  print("Количество способов подняться по лестнице из $n ступеней = $res");
+}

ru/codes/dart/chapter_dynamic_programming/coin_change.dart

@@ -0,0 +1,68 @@
+/**
+ * File: coin_change.dart
+ * Created Time: 2023-08-11
+ * Author: liuyuxin (gvenusleo@gmail.com)
+ */
+
+import 'dart:math';
+
+/* Размен монет: динамическое программирование */
+int coinChangeDP(List<int> coins, int amt) {
+  int n = coins.length;
+  int MAX = amt + 1;
+  // Инициализация таблицы dp
+  List<List<int>> dp = List.generate(n + 1, (index) => List.filled(amt + 1, 0));
+  // Переход состояний: первая строка и первый столбец
+  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] = min(dp[i - 1][a], dp[i][a - coins[i - 1]] + 1);
+      }
+    }
+  }
+  return dp[n][amt] != MAX ? dp[n][amt] : -1;
+}
+
+/* Размен монет: динамическое программирование с оптимизацией памяти */
+int coinChangeDPComp(List<int> coins, int amt) {
+  int n = coins.length;
+  int MAX = amt + 1;
+  // Инициализация таблицы dp
+  List<int> dp = List.filled(amt + 1, 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] = min(dp[a], dp[a - coins[i - 1]] + 1);
+      }
+    }
+  }
+  return dp[amt] != MAX ? dp[amt] : -1;
+}
+
+/* Driver Code */
+void main() {
+  List<int> coins = [1, 2, 5];
+  int amt = 4;
+
+  // Динамическое программирование
+  int res = coinChangeDP(coins, amt);
+  print("Минимальное число монет для набора целевой суммы = $res");
+
+  // Динамическое программирование с оптимизацией памяти
+  res = coinChangeDPComp(coins, amt);
+  print("Минимальное число монет для набора целевой суммы = $res");
+}

ru/codes/dart/chapter_dynamic_programming/coin_change_ii.dart

@@ -0,0 +1,64 @@
+/**
+ * File: coin_change_ii.dart
+ * Created Time: 2023-08-11
+ * Author: liuyuxin (gvenusleo@gmail.com)
+ */
+
+/* Размен монет II: динамическое программирование */
+int coinChangeIIDP(List<int> coins, int amt) {
+  int n = coins.length;
+  // Инициализация таблицы dp
+  List<List<int>> dp = List.generate(n + 1, (index) => List.filled(amt + 1, 0));
+  // Инициализация первого столбца
+  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(List<int> coins, int amt) {
+  int n = coins.length;
+  // Инициализация таблицы dp
+  List<int> dp = List.filled(amt + 1, 0);
+  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];
+}
+
+/* Driver Code */
+void main() {
+  List<int> coins = [1, 2, 5];
+  int amt = 5;
+
+  // Динамическое программирование
+  int res = coinChangeIIDP(coins, amt);
+  print("Количество комбинаций монет для набора целевой суммы = $res");
+
+  // Динамическое программирование с оптимизацией памяти
+  res = coinChangeIIDPComp(coins, amt);
+  print("Количество комбинаций монет для набора целевой суммы = $res");
+}

ru/codes/dart/chapter_dynamic_programming/edit_distance.dart

@@ -0,0 +1,125 @@
+/**
+ * File: edit_distance.dart
+ * Created Time: 2023-08-11
+ * Author: liuyuxin (gvenusleo@gmail.com)
+ */
+
+import 'dart:math';
+
+/* Редакционное расстояние: полный перебор */
+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 min(min(insert, delete), replace) + 1;
+}
+
+/* Редакционное расстояние: поиск с мемоизацией */
+int editDistanceDFSMem(String s, String t, List<List<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] = min(min(insert, delete), replace) + 1;
+  return mem[i][j];
+}
+
+/* Редакционное расстояние: динамическое программирование */
+int editDistanceDP(String s, String t) {
+  int n = s.length, m = t.length;
+  List<List<int>> dp = List.generate(n + 1, (_) => List.filled(m + 1, 0));
+  // Переход состояний: первая строка и первый столбец
+  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] = min(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;
+  List<int> dp = List.filled(m + 1, 0);
+  // Переход состояний: первая строка
+  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] = min(min(dp[j - 1], dp[j]), leftup) + 1;
+      }
+      leftup = temp; // Обновить до значения dp[i-1, j-1] для следующей итерации
+    }
+  }
+  return dp[m];
+}
+
+/* Driver Code */
+void main() {
+  String s = "bag";
+  String t = "pack";
+  int n = s.length, m = t.length;
+
+  // Полный перебор
+  int res = editDistanceDFS(s, t, n, m);
+  print("Чтобы преобразовать " + s + " в " + t + ", нужно минимум $res шагов");
+
+  // Поиск с мемоизацией
+  List<List<int>> mem = List.generate(n + 1, (_) => List.filled(m + 1, -1));
+  res = editDistanceDFSMem(s, t, mem, n, m);
+  print("Чтобы преобразовать " + s + " в " + t + ", нужно минимум $res шагов");
+
+  // Динамическое программирование
+  res = editDistanceDP(s, t);
+  print("Чтобы преобразовать " + s + " в " + t + ", нужно минимум $res шагов");
+
+  // Динамическое программирование с оптимизацией памяти
+  res = editDistanceDPComp(s, t);
+  print("Чтобы преобразовать " + s + " в " + t + ", нужно минимум $res шагов");
+}

ru/codes/dart/chapter_dynamic_programming/knapsack.dart

@@ -0,0 +1,116 @@
+/**
+ * File: knapsack.dart
+ * Created Time: 2023-08-11
+ * Author: liuyuxin (gvenusleo@gmail.com)
+ */
+
+import 'dart:math';
+
+/* Рюкзак 0-1: полный перебор */
+int knapsackDFS(List<int> wgt, List<int> val, int i, int c) {
+  // Если все предметы уже рассмотрены или в рюкзаке не осталось места, вернуть стоимость 0
+  if (i == 0 || c == 0) {
+    return 0;
+  }
+  // Если вместимость рюкзака превышена, можно только не класть предмет в рюкзак
+  if (wgt[i - 1] > c) {
+    return knapsackDFS(wgt, val, i - 1, c);
+  }
+  // Вычислить максимальную стоимость для случаев, когда предмет i не кладут и кладут
+  int no = knapsackDFS(wgt, val, i - 1, c);
+  int yes = knapsackDFS(wgt, val, i - 1, c - wgt[i - 1]) + val[i - 1];
+  // Вернуть вариант с большей стоимостью из двух возможных
+  return max(no, yes);
+}
+
+/* Рюкзак 0-1: поиск с мемоизацией */
+int knapsackDFSMem(
+  List<int> wgt,
+  List<int> val,
+  List<List<int>> mem,
+  int i,
+  int c,
+) {
+  // Если все предметы уже рассмотрены или в рюкзаке не осталось места, вернуть стоимость 0
+  if (i == 0 || c == 0) {
+    return 0;
+  }
+  // Если запись уже есть, вернуть сразу
+  if (mem[i][c] != -1) {
+    return mem[i][c];
+  }
+  // Если вместимость рюкзака превышена, можно только не класть предмет в рюкзак
+  if (wgt[i - 1] > c) {
+    return knapsackDFSMem(wgt, val, mem, i - 1, c);
+  }
+  // Вычислить максимальную стоимость для случаев, когда предмет i не кладут и кладут
+  int no = knapsackDFSMem(wgt, val, mem, i - 1, c);
+  int yes = knapsackDFSMem(wgt, val, mem, i - 1, c - wgt[i - 1]) + val[i - 1];
+  // Сохранить и вернуть вариант с большей стоимостью из двух решений
+  mem[i][c] = max(no, yes);
+  return mem[i][c];
+}
+
+/* Рюкзак 0-1: динамическое программирование */
+int knapsackDP(List<int> wgt, List<int> val, int cap) {
+  int n = wgt.length;
+  // Инициализация таблицы dp
+  List<List<int>> dp = List.generate(n + 1, (index) => List.filled(cap + 1, 0));
+  // Переход состояний
+  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] = max(dp[i - 1][c], dp[i - 1][c - wgt[i - 1]] + val[i - 1]);
+      }
+    }
+  }
+  return dp[n][cap];
+}
+
+/* Рюкзак 0-1: динамическое программирование с оптимизацией памяти */
+int knapsackDPComp(List<int> wgt, List<int> val, int cap) {
+  int n = wgt.length;
+  // Инициализация таблицы dp
+  List<int> dp = List.filled(cap + 1, 0);
+  // Переход состояний
+  for (int i = 1; i <= n; i++) {
+    // Обход в обратном порядке
+    for (int c = cap; c >= 1; c--) {
+      if (wgt[i - 1] <= c) {
+        // Большее из двух решений: не брать или взять предмет i
+        dp[c] = max(dp[c], dp[c - wgt[i - 1]] + val[i - 1]);
+      }
+    }
+  }
+  return dp[cap];
+}
+
+/* Driver Code */
+void main() {
+  List<int> wgt = [10, 20, 30, 40, 50];
+  List<int> val = [50, 120, 150, 210, 240];
+  int cap = 50;
+  int n = wgt.length;
+
+  // Полный перебор
+  int res = knapsackDFS(wgt, val, n, cap);
+  print("Максимальная стоимость предметов без превышения вместимости рюкзака = $res");
+
+  // Поиск с мемоизацией
+  List<List<int>> mem =
+      List.generate(n + 1, (index) => List.filled(cap + 1, -1));
+  res = knapsackDFSMem(wgt, val, mem, n, cap);
+  print("Максимальная стоимость предметов без превышения вместимости рюкзака = $res");
+
+  // Динамическое программирование
+  res = knapsackDP(wgt, val, cap);
+  print("Максимальная стоимость предметов без превышения вместимости рюкзака = $res");
+
+  // Динамическое программирование с оптимизацией памяти
+  res = knapsackDPComp(wgt, val, cap);
+  print("Максимальная стоимость предметов без превышения вместимости рюкзака = $res");
+}

ru/codes/dart/chapter_dynamic_programming/min_cost_climbing_stairs_dp.dart

@@ -0,0 +1,48 @@
+/**
+ * File: min_cost_climbing_stairs_dp.dart
+ * Created Time: 2023-08-11
+ * Author: liuyuxin (gvenusleo@gmail.com)
+ */
+
+import 'dart:math';
+
+/* Минимальная стоимость подъема по лестнице: динамическое программирование */
+int minCostClimbingStairsDP(List<int> cost) {
+  int n = cost.length - 1;
+  if (n == 1 || n == 2) return cost[n];
+  // Инициализация таблицы dp для хранения решений подзадач
+  List<int> dp = List.filled(n + 1, 0);
+  // Начальное состояние: заранее задать решения наименьших подзадач
+  dp[1] = cost[1];
+  dp[2] = cost[2];
+  // Переход состояний: постепенное решение больших подзадач через меньшие
+  for (int i = 3; i <= n; i++) {
+    dp[i] = min(dp[i - 1], dp[i - 2]) + cost[i];
+  }
+  return dp[n];
+}
+
+/* Минимальная стоимость подъема по лестнице: динамическое программирование с оптимизацией памяти */
+int minCostClimbingStairsDPComp(List<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 = min(a, tmp) + cost[i];
+    a = tmp;
+  }
+  return b;
+}
+
+/* Driver Code */
+void main() {
+  List<int> cost = [0, 1, 10, 1, 1, 1, 10, 1, 1, 10, 1];
+  print("Список стоимостей ступеней = $cost");
+
+  int res = minCostClimbingStairsDP(cost);
+  print("Минимальная стоимость подъема по лестнице = $res");
+
+  res = minCostClimbingStairsDPComp(cost);
+  print("Минимальная стоимость подъема по лестнице = $res");
+}

ru/codes/dart/chapter_dynamic_programming/min_path_sum.dart

@@ -0,0 +1,120 @@
+/**
+ * File: min_path_sum.dart
+ * Created Time: 2023-08-11
+ * Author: liuyuxin (gvenusleo@gmail.com)
+ */
+
+import 'dart:math';
+
+/* Минимальная сумма пути: полный перебор */
+int minPathSumDFS(List<List<int>> grid, int i, int j) {
+  // Если это верхняя левая ячейка, завершить поиск
+  if (i == 0 && j == 0) {
+    return grid[0][0];
+  }
+  // Если индексы строки или столбца выходят за границы, вернуть стоимость +∞
+  if (i < 0 || j < 0) {
+    // В Dart тип int — целое число фиксированного диапазона; значения, представляющего «бесконечность», не существует
+    return BigInt.from(2).pow(31).toInt();
+  }
+  // Вычислить минимальную стоимость пути из левого верхнего угла до (i-1, j) и (i, j-1)
+  int up = minPathSumDFS(grid, i - 1, j);
+  int left = minPathSumDFS(grid, i, j - 1);
+  // Вернуть минимальную стоимость пути из левого верхнего угла до (i, j)
+  return min(left, up) + grid[i][j];
+}
+
+/* Минимальная сумма пути: поиск с мемоизацией */
+int minPathSumDFSMem(List<List<int>> grid, List<List<int>> mem, int i, int j) {
+  // Если это верхняя левая ячейка, завершить поиск
+  if (i == 0 && j == 0) {
+    return grid[0][0];
+  }
+  // Если индексы строки или столбца выходят за границы, вернуть стоимость +∞
+  if (i < 0 || j < 0) {
+    // В Dart тип int — целое число фиксированного диапазона; значения, представляющего «бесконечность», не существует
+    return BigInt.from(2).pow(31).toInt();
+  }
+  // Если запись уже есть, вернуть сразу
+  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] = min(left, up) + grid[i][j];
+  return mem[i][j];
+}
+
+/* Минимальная сумма пути: динамическое программирование */
+int minPathSumDP(List<List<int>> grid) {
+  int n = grid.length, m = grid[0].length;
+  // Инициализация таблицы dp
+  List<List<int>> dp = List.generate(n, (i) => List.filled(m, 0));
+  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] = min(dp[i][j - 1], dp[i - 1][j]) + grid[i][j];
+    }
+  }
+  return dp[n - 1][m - 1];
+}
+
+/* Минимальная сумма пути: динамическое программирование с оптимизацией памяти */
+int minPathSumDPComp(List<List<int>> grid) {
+  int n = grid.length, m = grid[0].length;
+  // Инициализация таблицы dp
+  List<int> dp = List.filled(m, 0);
+  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] = min(dp[j - 1], dp[j]) + grid[i][j];
+    }
+  }
+  return dp[m - 1];
+}
+
+/* Driver Code */
+void main() {
+  List<List<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);
+  print("Минимальная сумма пути из левого верхнего угла в правый нижний = $res");
+
+// Поиск с мемоизацией
+  List<List<int>> mem = List.generate(n, (i) => List.filled(m, -1));
+  res = minPathSumDFSMem(grid, mem, n - 1, m - 1);
+  print("Минимальная сумма пути из левого верхнего угла в правый нижний = $res");
+
+// Динамическое программирование
+  res = minPathSumDP(grid);
+  print("Минимальная сумма пути из левого верхнего угла в правый нижний = $res");
+
+// Динамическое программирование с оптимизацией памяти
+  res = minPathSumDPComp(grid);
+  print("Минимальная сумма пути из левого верхнего угла в правый нижний = $res");
+}

ru/codes/dart/chapter_dynamic_programming/unbounded_knapsack.dart

@@ -0,0 +1,62 @@
+/**
+ * File: unbounded_knapsack.dart
+ * Created Time: 2023-08-11
+ * Author: liuyuxin (gvenusleo@gmail.com)
+ */
+
+import 'dart:math';
+
+/* Полный рюкзак: динамическое программирование */
+int unboundedKnapsackDP(List<int> wgt, List<int> val, int cap) {
+  int n = wgt.length;
+  // Инициализация таблицы dp
+  List<List<int>> dp = List.generate(n + 1, (index) => List.filled(cap + 1, 0));
+  // Переход состояний
+  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] = max(dp[i - 1][c], dp[i][c - wgt[i - 1]] + val[i - 1]);
+      }
+    }
+  }
+  return dp[n][cap];
+}
+
+/* Полный рюкзак: динамическое программирование с оптимизацией памяти */
+int unboundedKnapsackDPComp(List<int> wgt, List<int> val, int cap) {
+  int n = wgt.length;
+  // Инициализация таблицы dp
+  List<int> dp = List.filled(cap + 1, 0);
+  // Переход состояний
+  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] = max(dp[c], dp[c - wgt[i - 1]] + val[i - 1]);
+      }
+    }
+  }
+  return dp[cap];
+}
+
+/* Driver Code */
+void main() {
+  List<int> wgt = [1, 2, 3];
+  List<int> val = [5, 11, 15];
+  int cap = 4;
+
+  // Динамическое программирование
+  int res = unboundedKnapsackDP(wgt, val, cap);
+  print("Максимальная стоимость предметов без превышения вместимости рюкзака = $res");
+
+  // Динамическое программирование с оптимизацией памяти
+  int resComp = unboundedKnapsackDPComp(wgt, val, cap);
+  print("Максимальная стоимость предметов без превышения вместимости рюкзака = $resComp");
+}

ru/codes/dart/chapter_graph/graph_adjacency_list.dart

@@ -0,0 +1,124 @@
+/**
+ * File: graph_adjacency_list.dart
+ * Created Time: 2023-05-15
+ * Author: liuyuxin (gvenusleo@gmail.com)
+ */
+
+import '../utils/vertex.dart';
+
+/* Класс неориентированного графа на основе списка смежности */
+class GraphAdjList {
+  // Список смежности, где key — вершина, а value — все смежные ей вершины
+  Map<Vertex, List<Vertex>> adjList = {};
+
+  /* Конструктор */
+  GraphAdjList(List<List<Vertex>> edges) {
+    for (List<Vertex> edge in edges) {
+      addVertex(edge[0]);
+      addVertex(edge[1]);
+      addEdge(edge[0], edge[1]);
+    }
+  }
+
+  /* Получить число вершин */
+  int size() {
+    return adjList.length;
+  }
+
+  /* Добавление ребра */
+  void addEdge(Vertex vet1, Vertex vet2) {
+    if (!adjList.containsKey(vet1) ||
+        !adjList.containsKey(vet2) ||
+        vet1 == vet2) {
+      throw ArgumentError;
+    }
+    // Добавить ребро vet1 - vet2
+    adjList[vet1]!.add(vet2);
+    adjList[vet2]!.add(vet1);
+  }
+
+  /* Удаление ребра */
+  void removeEdge(Vertex vet1, Vertex vet2) {
+    if (!adjList.containsKey(vet1) ||
+        !adjList.containsKey(vet2) ||
+        vet1 == vet2) {
+      throw ArgumentError;
+    }
+    // Удалить ребро vet1 - vet2
+    adjList[vet1]!.remove(vet2);
+    adjList[vet2]!.remove(vet1);
+  }
+
+  /* Добавление вершины */
+  void addVertex(Vertex vet) {
+    if (adjList.containsKey(vet)) return;
+    // Добавить новый список в список смежности
+    adjList[vet] = [];
+  }
+
+  /* Удаление вершины */
+  void removeVertex(Vertex vet) {
+    if (!adjList.containsKey(vet)) {
+      throw ArgumentError;
+    }
+    // Удалить из списка смежности список, соответствующий вершине vet
+    adjList.remove(vet);
+    // Обойти списки других вершин и удалить все ребра, содержащие vet
+    adjList.forEach((key, value) {
+      value.remove(vet);
+    });
+  }
+
+  /* Вывести список смежности */
+  void printAdjList() {
+    print("Список смежности =");
+    adjList.forEach((key, value) {
+      List<int> tmp = [];
+      for (Vertex vertex in value) {
+        tmp.add(vertex.val);
+      }
+      print("${key.val}: $tmp,");
+    });
+  }
+}
+
+/* Driver Code */
+void main() {
+  /* Инициализация неориентированного графа */
+  List<Vertex> v = Vertex.valsToVets([1, 3, 2, 5, 4]);
+  List<List<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 = GraphAdjList(edges);
+  print("\nГраф после инициализации");
+  graph.printAdjList();
+
+  /* Добавление ребра */
+  // Вершины 1 и 2 соответствуют v[0] и v[2]
+  graph.addEdge(v[0], v[2]);
+  print("\nГраф после добавления ребра 1-2");
+  graph.printAdjList();
+
+  /* Удаление ребра */
+  // Вершины 1 и 3 соответствуют v[0] и v[1]
+  graph.removeEdge(v[0], v[1]);
+  print("\nГраф после удаления ребра 1-3");
+  graph.printAdjList();
+
+  /* Добавление вершины */
+  Vertex v5 = Vertex(6);
+  graph.addVertex(v5);
+  print("\nГраф после добавления вершины 6");
+  graph.printAdjList();
+
+  /* Удаление вершины */
+  // Вершина 3 соответствует v[1]
+  graph.removeVertex(v[1]);
+  print("\nГраф после удаления вершины 3");
+  graph.printAdjList();
+}

ru/codes/dart/chapter_graph/graph_adjacency_matrix.dart

@@ -0,0 +1,133 @@
+/**
+ * File: graph_adjacency_matrix.dart
+ * Created Time: 2023-05-15
+ * Author: liuyuxin (gvenusleo@gmail.com)
+ */
+
+import '../utils/print_util.dart';
+
+/* Класс неориентированного графа на основе матрицы смежности */
+class GraphAdjMat {
+  List<int> vertices = []; // Элемент вершины: элемент представляет «значение вершины», индекс представляет «индекс вершины»
+  List<List<int>> adjMat = []; // Матрица смежности, где индексы строк и столбцов соответствуют «индексам вершин»
+
+  /* Конструктор */
+  GraphAdjMat(List<int> vertices, List<List<int>> edges) {
+    this.vertices = [];
+    this.adjMat = [];
+    // Добавление вершины
+    for (int val in vertices) {
+      addVertex(val);
+    }
+    // Добавить ребра
+    // Обратите внимание: элементы edges представляют собой индексы вершин, то есть соответствуют индексам элементов vertices
+    for (List<int> e in edges) {
+      addEdge(e[0], e[1]);
+    }
+  }
+
+  /* Получить число вершин */
+  int size() {
+    return vertices.length;
+  }
+
+  /* Добавление вершины */
+  void addVertex(int val) {
+    int n = size();
+    // Добавить значение новой вершины в список вершин
+    vertices.add(val);
+    // Добавить строку в матрицу смежности
+    List<int> newRow = List.filled(n, 0, growable: true);
+    adjMat.add(newRow);
+    // Добавить столбец в матрицу смежности
+    for (List<int> row in adjMat) {
+      row.add(0);
+    }
+  }
+
+  /* Удаление вершины */
+  void removeVertex(int index) {
+    if (index >= size()) {
+      throw IndexError;
+    }
+    // Удалить вершину с индексом index из списка вершин
+    vertices.removeAt(index);
+    // Удалить строку с индексом index из матрицы смежности
+    adjMat.removeAt(index);
+    // Удалить столбец с индексом index из матрицы смежности
+    for (List<int> row in adjMat) {
+      row.removeAt(index);
+    }
+  }
+
+  /* Добавление ребра */
+  // Параметры i и j соответствуют индексам элементов vertices
+  void addEdge(int i, int j) {
+    // Обработка выхода индекса за границы и случая равенства
+    if (i < 0 || j < 0 || i >= size() || j >= size() || i == j) {
+      throw IndexError;
+    }
+    // В неориентированном графе матрица смежности симметрична относительно главной диагонали, то есть выполняется (i, j) == (j, i)
+    adjMat[i][j] = 1;
+    adjMat[j][i] = 1;
+  }
+
+  /* Удаление ребра */
+  // Параметры i и j соответствуют индексам элементов vertices
+  void removeEdge(int i, int j) {
+    // Обработка выхода индекса за границы и случая равенства
+    if (i < 0 || j < 0 || i >= size() || j >= size() || i == j) {
+      throw IndexError;
+    }
+    adjMat[i][j] = 0;
+    adjMat[j][i] = 0;
+  }
+
+  /* Вывести матрицу смежности */
+  void printAdjMat() {
+    print("Список вершин = $vertices");
+    print("Матрица смежности = ");
+    printMatrix(adjMat);
+  }
+}
+
+/* Driver Code */
+void main() {
+  /* Инициализация неориентированного графа */
+  // Обратите внимание: элементы edges представляют индексы вершин, то есть соответствуют индексам элементов vertices
+  List<int> vertices = [1, 3, 2, 5, 4];
+  List<List<int>> edges = [
+    [0, 1],
+    [0, 3],
+    [1, 2],
+    [2, 3],
+    [2, 4],
+    [3, 4],
+  ];
+  GraphAdjMat graph = GraphAdjMat(vertices, edges);
+  print("\nГраф после инициализации");
+  graph.printAdjMat();
+
+  /* Добавление ребра */
+  // Индексы вершин 1 и 2 равны 0 и 2 соответственно
+  graph.addEdge(0, 2);
+  print("\nГраф после добавления ребра 1-2");
+  graph.printAdjMat();
+
+  /* Удаление ребра */
+  // Индексы вершин 1 и 3 равны 0 и 1 соответственно
+  graph.removeEdge(0, 1);
+  print("\nГраф после удаления ребра 1-3");
+  graph.printAdjMat();
+
+  /* Добавление вершины */
+  graph.addVertex(6);
+  print("\nГраф после добавления вершины 6");
+  graph.printAdjMat();
+
+  /* Удаление вершины */
+  // Индекс вершины 3 равен 1
+  graph.removeVertex(1);
+  print("\nГраф после удаления вершины 3");
+  graph.printAdjMat();
+}

ru/codes/dart/chapter_graph/graph_bfs.dart

@@ -0,0 +1,66 @@
+/**
+ * File: graph_bfs.dart
+ * Created Time: 2023-05-15
+ * Author: liuyuxin (gvenusleo@gmail.com)
+ */
+
+import 'dart:collection';
+
+import '../utils/vertex.dart';
+import 'graph_adjacency_list.dart';
+
+/* Обход в ширину */
+List<Vertex> graphBFS(GraphAdjList graph, Vertex startVet) {
+  // Использовать список смежности для представления графа, чтобы получать все смежные вершины заданной вершины
+  // Последовательность обхода вершин
+  List<Vertex> res = [];
+  // Хеш-множество для хранения уже посещенных вершин
+  Set<Vertex> visited = {};
+  visited.add(startVet);
+  // Очередь используется для реализации BFS
+  Queue<Vertex> que = Queue();
+  que.add(startVet);
+  // Начиная с вершины vet, продолжать цикл, пока не будут посещены все вершины
+  while (que.isNotEmpty) {
+    Vertex vet = que.removeFirst(); // Извлечь головную вершину из очереди
+    res.add(vet); // Отметить посещенную вершину
+    // Обойти все смежные вершины данной вершины
+    for (Vertex adjVet in graph.adjList[vet]!) {
+      if (visited.contains(adjVet)) {
+        continue; // Пропустить уже посещенную вершину
+      }
+      que.add(adjVet); // Помещать в очередь только непосещенные вершины
+      visited.add(adjVet); // Отметить эту вершину как посещенную
+    }
+  }
+  // Вернуть последовательность обхода вершин
+  return res;
+}
+
+/* Dirver Code */
+void main() {
+  /* Инициализация неориентированного графа */
+  List<Vertex> v = Vertex.valsToVets([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]);
+  List<List<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 = GraphAdjList(edges);
+  print("\nГраф после инициализации");
+  graph.printAdjList();
+
+  /* Обход в ширину */
+  List<Vertex> res = graphBFS(graph, v[0]);
+  print("\nПоследовательность вершин при обходе в ширину (BFS)");
+  print(Vertex.vetsToVals(res));
+}

ru/codes/dart/chapter_graph/graph_dfs.dart

@@ -0,0 +1,59 @@
+/**
+ * File: graph_dfs.dart
+ * Created Time: 2023-05-15
+ * Author: liuyuxin (gvenusleo@gmail.com)
+ */
+
+import '../utils/vertex.dart';
+import 'graph_adjacency_list.dart';
+
+/* Вспомогательная функция обхода в глубину */
+void dfs(
+  GraphAdjList graph,
+  Set<Vertex> visited,
+  List<Vertex> res,
+  Vertex vet,
+) {
+  res.add(vet); // Отметить посещенную вершину
+  visited.add(vet); // Отметить эту вершину как посещенную
+  // Обойти все смежные вершины данной вершины
+  for (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 = [];
+  // Хеш-множество для хранения уже посещенных вершин
+  Set<Vertex> visited = {};
+  dfs(graph, visited, res, startVet);
+  return res;
+}
+
+/* Driver Code */
+void main() {
+  /* Инициализация неориентированного графа */
+  List<Vertex> v = Vertex.valsToVets([0, 1, 2, 3, 4, 5, 6]);
+  List<List<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 = GraphAdjList(edges);
+  print("\nГраф после инициализации");
+  graph.printAdjList();
+
+  /* Обход в глубину */
+  List<Vertex> res = graphDFS(graph, v[0]);
+  print("\nПоследовательность вершин при обходе в глубину (DFS)");
+  print(Vertex.vetsToVals(res));
+}

ru/codes/dart/chapter_greedy/coin_change_greedy.dart

@@ -0,0 +1,50 @@
+/**
+ * File: coin_change_greedy.dart
+ * Created Time: 2023-08-11
+ * Author: liuyuxin (gvenusleo@gmail.com)
+ */
+
+/* Размен монет: жадный алгоритм */
+int coinChangeGreedy(List<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;
+}
+
+/* Driver Code */
+void main() {
+  // Жадный подход: гарантирует нахождение глобально оптимального решения
+  List<int> coins = [1, 5, 10, 20, 50, 100];
+  int amt = 186;
+  int res = coinChangeGreedy(coins, amt);
+  print("\ncoins = $coins, amt = $amt");
+  print("Минимальное число монет для набора суммы $amt = $res");
+
+  // Жадный подход: не гарантирует нахождение глобально оптимального решения
+  coins = [1, 20, 50];
+  amt = 60;
+  res = coinChangeGreedy(coins, amt);
+  print("\ncoins = $coins, amt = $amt");
+  print("Минимальное число монет для набора суммы $amt = $res");
+  print("На самом деле минимум равен 3: 20 + 20 + 20");
+
+  // Жадный подход: не гарантирует нахождение глобально оптимального решения
+  coins = [1, 49, 50];
+  amt = 98;
+  res = coinChangeGreedy(coins, amt);
+  print("\ncoins = $coins, amt = $amt");
+  print("Минимальное число монет для набора суммы $amt = $res");
+  print("На самом деле минимум равен 2: 49 + 49");
+}

ru/codes/dart/chapter_greedy/fractional_knapsack.dart

@@ -0,0 +1,47 @@
+/**
+ * File: fractional_knapsack.dart
+ * Created Time: 2023-08-11
+ * Author: liuyuxin (gvenusleo@gmail.com)
+ */
+
+/* Предмет */
+class Item {
+  int w; // Вес предмета
+  int v; // Стоимость предмета
+
+  Item(this.w, this.v);
+}
+
+/* Дробный рюкзак: жадный алгоритм */
+double fractionalKnapsack(List<int> wgt, List<int> val, int cap) {
+  // Создать список предметов с двумя свойствами: вес и стоимость
+  List<Item> items = List.generate(wgt.length, (i) => Item(wgt[i], val[i]));
+  // Отсортировать по удельной стоимости item.v / item.w в порядке убывания
+  items.sort((a, b) => (b.v / b.w).compareTo(a.v / a.w));
+  // Циклический жадный выбор
+  double res = 0;
+  for (Item item in items) {
+    if (item.w <= cap) {
+      // Если оставшейся вместимости достаточно, положить в рюкзак текущий предмет целиком
+      res += item.v;
+      cap -= item.w;
+    } else {
+      // Если оставшейся вместимости недостаточно, положить в рюкзак часть текущего предмета
+      res += item.v / item.w * cap;
+      // Свободной вместимости больше не осталось, поэтому выйти из цикла
+      break;
+    }
+  }
+  return res;
+}
+
+/* Driver Code */
+void main() {
+  List<int> wgt = [10, 20, 30, 40, 50];
+  List<int> val = [50, 120, 150, 210, 240];
+  int cap = 50;
+
+  // Жадный алгоритм
+  double res = fractionalKnapsack(wgt, val, cap);
+  print("Максимальная стоимость предметов без превышения вместимости рюкзака = $res");
+}

ru/codes/dart/chapter_greedy/max_capacity.dart

@@ -0,0 +1,37 @@
+/**
+ * File: max_capacity.dart
+ * Created Time: 2023-08-11
+ * Author: liuyuxin (gvenusleo@gmail.com)
+ */
+
+import 'dart:math';
+
+/* Максимальная вместимость: жадный алгоритм */
+int maxCapacity(List<int> ht) {
+  // Инициализировать i и j так, чтобы они располагались по двум концам массива
+  int i = 0, j = ht.length - 1;
+  // Начальная максимальная вместимость равна 0
+  int res = 0;
+  // Выполнять жадный выбор в цикле, пока две доски не встретятся
+  while (i < j) {
+    // Обновить максимальную вместимость
+    int cap = min(ht[i], ht[j]) * (j - i);
+    res = max(res, cap);
+    // Сдвигать внутрь более короткую сторону
+    if (ht[i] < ht[j]) {
+      i++;
+    } else {
+      j--;
+    }
+  }
+  return res;
+}
+
+/* Driver Code */
+void main() {
+  List<int> ht = [3, 8, 5, 2, 7, 7, 3, 4];
+
+  // Жадный алгоритм
+  int res = maxCapacity(ht);
+  print("Максимальная вместимость = $res");
+}

ru/codes/dart/chapter_greedy/max_product_cutting.dart

@@ -0,0 +1,37 @@
+/**
+ * File: max_product_cutting.dart
+ * Created Time: 2023-08-11
+ * Author: liuyuxin (gvenusleo@gmail.com)
+ */
+
+import 'dart:math';
+
+/* Максимальное произведение разрезания: жадный алгоритм */
+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 (pow(3, a - 1) * 2 * 2).toInt();
+  }
+  if (b == 2) {
+    // Если остаток равен 2, ничего не делать
+    return (pow(3, a) * 2).toInt();
+  }
+  // Если остаток равен 0, ничего не делать
+  return pow(3, a).toInt();
+}
+
+/* Driver Code */
+void main() {
+  int n = 58;
+
+  // Жадный алгоритм
+  int res = maxProductCutting(n);
+  print("Максимальное произведение после разрезания = $res");
+}

ru/codes/dart/chapter_hashing/array_hash_map.dart

@@ -0,0 +1,126 @@
+/**
+ * File: array_hash_map.dart
+ * Created Time: 2023-03-29
+ * Author: liuyuxin (gvenusleo@gmail.com)
+ */
+
+/* Пара ключ-значение */
+class Pair {
+  int key;
+  String val;
+  Pair(this.key, this.val);
+}
+
+/* Хеш-таблица на основе массива */
+class ArrayHashMap {
+  late List<Pair?> _buckets;
+
+  ArrayHashMap() {
+    // Инициализировать массив, содержащий 100 корзин
+    _buckets = List.filled(100, null);
+  }
+
+  /* Хеш-функция */
+  int _hashFunc(int key) {
+    final int index = key % 100;
+    return index;
+  }
+
+  /* Операция поиска */
+  String? get(int key) {
+    final int index = _hashFunc(key);
+    final Pair? pair = _buckets[index];
+    if (pair == null) {
+      return null;
+    }
+    return pair.val;
+  }
+
+  /* Операция добавления */
+  void put(int key, String val) {
+    final Pair pair = Pair(key, val);
+    final int index = _hashFunc(key);
+    _buckets[index] = pair;
+  }
+
+  /* Операция удаления */
+  void remove(int key) {
+    final int index = _hashFunc(key);
+    _buckets[index] = null;
+  }
+
+  /* Получить все пары ключ-значение */
+  List<Pair> pairSet() {
+    List<Pair> pairSet = [];
+    for (final Pair? pair in _buckets) {
+      if (pair != null) {
+        pairSet.add(pair);
+      }
+    }
+    return pairSet;
+  }
+
+  /* Получить все ключи */
+  List<int> keySet() {
+    List<int> keySet = [];
+    for (final Pair? pair in _buckets) {
+      if (pair != null) {
+        keySet.add(pair.key);
+      }
+    }
+    return keySet;
+  }
+
+  /* Получить все значения */
+  List<String> values() {
+    List<String> valueSet = [];
+    for (final Pair? pair in _buckets) {
+      if (pair != null) {
+        valueSet.add(pair.val);
+      }
+    }
+    return valueSet;
+  }
+
+  /* Вывести хеш-таблицу */
+  void printHashMap() {
+    for (final Pair kv in pairSet()) {
+      print("${kv.key} -> ${kv.val}");
+    }
+  }
+}
+
+/* Driver Code */
+void main() {
+  /* Инициализация хеш-таблицы */
+  final ArrayHashMap map = ArrayHashMap();
+
+  /* Операция добавления */
+  // Добавить пару (key, value) в хеш-таблицу
+  map.put(12836, "Сяо Ха");
+  map.put(15937, "Сяо Ло");
+  map.put(16750, "Сяо Суань");
+  map.put(13276, "Сяо Фа");
+  map.put(10583, "Сяо Я");
+  print("\nПосле добавления хеш-таблица имеет вид\nКлюч -> Значение");
+  map.printHashMap();
+
+  /* Операция поиска */
+  // Ввести в хеш-таблицу ключ key и получить значение value
+  String? name = map.get(15937);
+  print("\nДля номера 15937 найдено имя $name");
+
+  /* Операция удаления */
+  // Удалить пару (key, value) из хеш-таблицы
+  map.remove(10583);
+  print("\nПосле удаления 10583 хеш-таблица имеет вид\nКлюч -> Значение");
+  map.printHashMap();
+
+  /* Обход хеш-таблицы */
+  print("\nОтдельный обход пар ключ-значение");
+  map.pairSet().forEach((kv) => print("${kv.key} -> ${kv.val}"));
+  print("\nОтдельный обход ключей");
+  map.keySet().forEach((key) => print("$key"));
+  print("\nОтдельный обход значений");
+  map.values().forEach((val) => print("$val"));
+}

ru/codes/dart/chapter_hashing/built_in_hash.dart

@@ -0,0 +1,34 @@
+/**
+ * File: built_in_hash.dart
+ * Created Time: 2023-06-25
+ * Author: liuyuxin (gvenusleo@gmail.com)
+ */
+
+import '../chapter_stack_and_queue/linkedlist_deque.dart';
+
+/* Driver Code */
+void main() {
+  int _num = 3;
+  int hashNum = _num.hashCode;
+  print("Хеш-значение целого числа $_num = $hashNum");
+
+  bool bol = true;
+  int hashBol = bol.hashCode;
+  print("Хеш-значение булева значения $bol = $hashBol");
+
+  double dec = 3.14159;
+  int hashDec = dec.hashCode;
+  print("Хеш-значение десятичного числа $dec = $hashDec");
+
+  String str = "Hello Algo";
+  int hashStr = str.hashCode;
+  print("Хеш-значение строки $str = $hashStr");
+
+  List arr = [12836, "Сяо Ха"];
+  int hashArr = arr.hashCode;
+  print("Хеш-значение массива $arr = $hashArr");
+
+  ListNode obj = new ListNode(0);
+  int hashObj = obj.hashCode;
+  print("Хеш-значение объекта узла $obj = $hashObj");
+}

ru/codes/dart/chapter_hashing/hash_map.dart

@@ -0,0 +1,41 @@
+/**
+ * File: hash_map.dart
+ * Created Time: 2023-03-29
+ * Author: liuyuxin (gvenusleo@gmail.com)
+ */
+
+/* Driver Code */
+void main() {
+  /* Инициализация хеш-таблицы */
+  final Map<int, String> map = {};
+
+  /* Операция добавления */
+  // Добавить пару (key, value) в хеш-таблицу
+  map[12836] = "Сяо Ха";
+  map[15937] = "Сяо Ло";
+  map[16750] = "Сяо Суань";
+  map[13276] = "Сяо Фа";
+  map[10583] = "Сяо Я";
+  print("\nПосле добавления хеш-таблица имеет вид\nКлюч -> Значение");
+  map.forEach((key, value) => print("$key -> $value"));
+
+  /* Операция поиска */
+  // Ввести в хеш-таблицу ключ key и получить значение value
+  final String? name = map[15937];
+  print("\nДля номера 15937 найдено имя $name");
+
+  /* Операция удаления */
+  // Удалить пару (key, value) из хеш-таблицы
+  map.remove(10583);
+  print("\nПосле удаления 10583 хеш-таблица имеет вид\nКлюч -> Значение");
+  map.forEach((key, value) => print("$key -> $value"));
+
+  /* Обход хеш-таблицы */
+  print("\nОтдельный обход пар ключ-значение");
+  map.forEach((key, value) => print("$key -> $value"));
+  print("\nОтдельный обход ключей");
+  map.keys.forEach((key) => print(key));
+  print("\nОтдельный обход значений");
+  map.forEach((key, value) => print("$value"));
+  map.values.forEach((value) => print(value));
+}

ru/codes/dart/chapter_hashing/hash_map_chaining.dart

@@ -0,0 +1,138 @@
+/**
+ * File: hash_map_chaining.dart
+ * Created Time: 2023-06-24
+ * Author: liuyuxin (gvenusleo@gmail.com)
+ */
+
+import 'array_hash_map.dart';
+
+/* Хеш-таблица с цепочками */
+class HashMapChaining {
+  late int size; // Число пар ключ-значение
+  late int capacity; // Вместимость хеш-таблицы
+  late double loadThres; // Порог коэффициента загрузки для запуска расширения
+  late int extendRatio; // Коэффициент расширения
+  late List<List<Pair>> buckets; // Массив корзин
+
+  /* Конструктор */
+  HashMapChaining() {
+    size = 0;
+    capacity = 4;
+    loadThres = 2.0 / 3.0;
+    extendRatio = 2;
+    buckets = List.generate(capacity, (_) => []);
+  }
+
+  /* Хеш-функция */
+  int hashFunc(int key) {
+    return key % capacity;
+  }
+
+  /* Коэффициент загрузки */
+  double loadFactor() {
+    return size / capacity;
+  }
+
+  /* Операция поиска */
+  String? get(int key) {
+    int index = hashFunc(key);
+    List<Pair> bucket = buckets[index];
+    // Обойти корзину; если найден key, вернуть соответствующее val
+    for (Pair pair in bucket) {
+      if (pair.key == key) {
+        return pair.val;
+      }
+    }
+    // Если key не найден, вернуть null
+    return null;
+  }
+
+  /* Операция добавления */
+  void put(int key, String val) {
+    // Когда коэффициент загрузки превышает порог, выполнить расширение
+    if (loadFactor() > loadThres) {
+      extend();
+    }
+    int index = hashFunc(key);
+    List<Pair> bucket = buckets[index];
+    // Обойти корзину; если встретился указанный key, обновить соответствующее val и вернуть
+    for (Pair pair in bucket) {
+      if (pair.key == key) {
+        pair.val = val;
+        return;
+      }
+    }
+    // Если такого key нет, добавить пару ключ-значение в конец
+    Pair pair = Pair(key, val);
+    bucket.add(pair);
+    size++;
+  }
+
+  /* Операция удаления */
+  void remove(int key) {
+    int index = hashFunc(key);
+    List<Pair> bucket = buckets[index];
+    // Обойти корзину и удалить из нее пару ключ-значение
+    for (Pair pair in bucket) {
+      if (pair.key == key) {
+        bucket.remove(pair);
+        size--;
+        break;
+      }
+    }
+  }
+
+  /* Расширить хеш-таблицу */
+  void extend() {
+    // Временно сохранить исходную хеш-таблицу
+    List<List<Pair>> bucketsTmp = buckets;
+    // Инициализация новой хеш-таблицы после расширения
+    capacity *= extendRatio;
+    buckets = List.generate(capacity, (_) => []);
+    size = 0;
+    // Перенести пары ключ-значение из исходной хеш-таблицы в новую
+    for (List<Pair> bucket in bucketsTmp) {
+      for (Pair pair in bucket) {
+        put(pair.key, pair.val);
+      }
+    }
+  }
+
+  /* Вывести хеш-таблицу */
+  void printHashMap() {
+    for (List<Pair> bucket in buckets) {
+      List<String> res = [];
+      for (Pair pair in bucket) {
+        res.add("${pair.key} -> ${pair.val}");
+      }
+      print(res);
+    }
+  }
+}
+
+/* Driver Code */
+void main() {
+  /* Инициализация хеш-таблицы */
+  HashMapChaining map = HashMapChaining();
+
+  /* Операция добавления */
+  // Добавить пару (key, value) в хеш-таблицу
+  map.put(12836, "Сяо Ха");
+  map.put(15937, "Сяо Ло");
+  map.put(16750, "Сяо Суань");
+  map.put(13276, "Сяо Фа");
+  map.put(10583, "Сяо Я");
+  print("\nПосле добавления хеш-таблица имеет вид\nКлюч -> Значение");
+  map.printHashMap();
+
+  /* Операция поиска */
+  // Ввести в хеш-таблицу ключ key и получить значение value
+  String? name = map.get(13276);
+  print("\nДля номера 13276 найдено имя ${name}");
+
+  /* Операция удаления */
+  // Удалить пару (key, value) из хеш-таблицы
+  map.remove(12836);
+  print("\nПосле удаления 12836 хеш-таблица имеет вид\nКлюч -> Значение");
+  map.printHashMap();
+}

ru/codes/dart/chapter_hashing/hash_map_open_addressing.dart

@@ -0,0 +1,157 @@
+/**
+ * File: hash_map_open_addressing.dart
+ * Created Time: 2023-06-25
+ * Author: liuyuxin (gvenusleo@gmail.com)
+ */
+
+import 'array_hash_map.dart';
+
+/* Хеш-таблица с открытой адресацией */
+class HashMapOpenAddressing {
+  late int _size; // Число пар ключ-значение
+  int _capacity = 4; // Вместимость хеш-таблицы
+  double _loadThres = 2.0 / 3.0; // Порог коэффициента загрузки для запуска расширения
+  int _extendRatio = 2; // Коэффициент расширения
+  late List<Pair?> _buckets; // Массив корзин
+  Pair _TOMBSTONE = Pair(-1, "-1"); // Удалить метку
+
+  /* Конструктор */
+  HashMapOpenAddressing() {
+    _size = 0;
+    _buckets = List.generate(_capacity, (index) => null);
+  }
+
+  /* Хеш-функция */
+  int hashFunc(int key) {
+    return key % _capacity;
+  }
+
+  /* Коэффициент загрузки */
+  double loadFactor() {
+    return _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;
+  }
+
+  /* Операция поиска */
+  String? get(int key) {
+    // Найти индекс корзины, соответствующий key
+    int index = findBucket(key);
+    // Если пара ключ-значение найдена, вернуть соответствующее val
+    if (_buckets[index] != null && _buckets[index] != _TOMBSTONE) {
+      return _buckets[index]!.val;
+    }
+    // Если пары ключ-значение не существует, вернуть null
+    return null;
+  }
+
+  /* Операция добавления */
+  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++;
+  }
+
+  /* Операция удаления */
+  void remove(int key) {
+    // Найти индекс корзины, соответствующий key
+    int index = findBucket(key);
+    // Если пара ключ-значение найдена, заменить ее меткой удаления
+    if (_buckets[index] != null && _buckets[index] != _TOMBSTONE) {
+      _buckets[index] = _TOMBSTONE;
+      _size--;
+    }
+  }
+
+  /* Расширить хеш-таблицу */
+  void extend() {
+    // Временно сохранить исходную хеш-таблицу
+    List<Pair?> bucketsTmp = _buckets;
+    // Инициализация новой хеш-таблицы после расширения
+    _capacity *= _extendRatio;
+    _buckets = List.generate(_capacity, (index) => null);
+    _size = 0;
+    // Перенести пары ключ-значение из исходной хеш-таблицы в новую
+    for (Pair? pair in bucketsTmp) {
+      if (pair != null && pair != _TOMBSTONE) {
+        put(pair.key, pair.val);
+      }
+    }
+  }
+
+  /* Вывести хеш-таблицу */
+  void printHashMap() {
+    for (Pair? pair in _buckets) {
+      if (pair == null) {
+        print("null");
+      } else if (pair == _TOMBSTONE) {
+        print("TOMBSTONE");
+      } else {
+        print("${pair.key} -> ${pair.val}");
+      }
+    }
+  }
+}
+
+/* Driver Code */
+void main() {
+  /* Инициализация хеш-таблицы */
+  HashMapOpenAddressing map = HashMapOpenAddressing();
+
+  /* Операция добавления */
+  // Добавить пару (key, value) в хеш-таблицу
+  map.put(12836, "Сяо Ха");
+  map.put(15937, "Сяо Ло");
+  map.put(16750, "Сяо Суань");
+  map.put(13276, "Сяо Фа");
+  map.put(10583, "Сяо Я");
+  print("\nПосле добавления хеш-таблица имеет вид\nКлюч -> Значение");
+  map.printHashMap();
+
+  /* Операция поиска */
+  // Ввести в хеш-таблицу ключ key и получить значение value
+  String? name = map.get(13276);
+  print("\nДля номера 13276 найдено имя $name");
+
+  /* Операция удаления */
+  // Удалить пару (key, value) из хеш-таблицы
+  map.remove(16750);
+  print("\nПосле удаления 16750 хеш-таблица имеет вид\nКлюч -> Значение");
+  map.printHashMap();
+}

ru/codes/dart/chapter_hashing/simple_hash.dart

@@ -0,0 +1,62 @@
+/**
+ * File: simple_hash.dart
+ * Created Time: 2023-06-25
+ * Author: liuyuxin (gvenusleo@gmail.com)
+ */
+
+/* Аддитивное хеширование */
+int addHash(String key) {
+  int hash = 0;
+  final int MODULUS = 1000000007;
+  for (int i = 0; i < key.length; i++) {
+    hash = (hash + key.codeUnitAt(i)) % MODULUS;
+  }
+  return hash;
+}
+
+/* Мультипликативное хеширование */
+int mulHash(String key) {
+  int hash = 0;
+  final int MODULUS = 1000000007;
+  for (int i = 0; i < key.length; i++) {
+    hash = (31 * hash + key.codeUnitAt(i)) % MODULUS;
+  }
+  return hash;
+}
+
+/* XOR-хеширование */
+int xorHash(String key) {
+  int hash = 0;
+  final int MODULUS = 1000000007;
+  for (int i = 0; i < key.length; i++) {
+    hash ^= key.codeUnitAt(i);
+  }
+  return hash & MODULUS;
+}
+
+/* Хеширование с циклическим сдвигом */
+int rotHash(String key) {
+  int hash = 0;
+  final int MODULUS = 1000000007;
+  for (int i = 0; i < key.length; i++) {
+    hash = ((hash << 4) ^ (hash >> 28) ^ key.codeUnitAt(i)) % MODULUS;
+  }
+  return hash;
+}
+
+/* Dirver Code */
+void main() {
+  String key = "Hello Algo";
+
+  int hash = addHash(key);
+  print("Хеш-сумма сложением = $hash");
+
+  hash = mulHash(key);
+  print("Хеш-сумма умножением = $hash");
+
+  hash = xorHash(key);
+  print("Хеш-сумма XOR = $hash");
+
+  hash = rotHash(key);
+  print("Хеш-сумма с циклическим сдвигом = $hash");
+}

ru/codes/dart/chapter_heap/my_heap.dart

@@ -0,0 +1,151 @@
+/**
+ * File: my_heap.dart
+ * Created Time: 2023-04-09
+ * Author: liuyuxin (gvenusleo@gmail.com)
+ */
+
+import '../utils/print_util.dart';
+
+/* Максимальная куча */
+class MaxHeap {
+  late List<int> _maxHeap;
+
+  /* Конструктор, строящий кучу по входному списку */
+  MaxHeap(List<int> nums) {
+    // Добавить элементы списка в кучу без изменений
+    _maxHeap = nums;
+    // Выполнить heapify для всех узлов, кроме листовых
+    for (int i = _parent(size() - 1); 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; // Округление вниз при делении
+  }
+
+  /* Поменять элементы местами */
+  void _swap(int i, int j) {
+    int tmp = _maxHeap[i];
+    _maxHeap[i] = _maxHeap[j];
+    _maxHeap[j] = tmp;
+  }
+
+  /* Получение размера кучи */
+  int size() {
+    return _maxHeap.length;
+  }
+
+  /* Проверка, пуста ли куча */
+  bool isEmpty() {
+    return size() == 0;
+  }
+
+  /* Доступ к элементу на вершине кучи */
+  int peek() {
+    return _maxHeap[0];
+  }
+
+  /* Добавление элемента в кучу */
+  void push(int val) {
+    // Добавление узла
+    _maxHeap.add(val);
+    // Просеивание снизу вверх
+    siftUp(size() - 1);
+  }
+
+  /* Начиная с узла i, выполнить просеивание снизу вверх */
+  void siftUp(int i) {
+    while (true) {
+      // Получение родительского узла для узла i
+      int p = _parent(i);
+      // Завершить heapify, когда «корневой узел уже пройден» или «узел не требует исправления»
+      if (p < 0 || _maxHeap[i] <= _maxHeap[p]) {
+        break;
+      }
+      // Поменять два узла местами
+      _swap(i, p);
+      // Циклическое просеивание вверх
+      i = p;
+    }
+  }
+
+  /* Извлечение элемента из кучи */
+  int pop() {
+    // Обработка пустого случая
+    if (isEmpty()) throw Exception('куча пуста');
+    // Поменять корневой узел с самым правым листом местами (поменять первый и последний элементы)
+    _swap(0, size() - 1);
+    // Удаление узла
+    int val = _maxHeap.removeLast();
+    // Просеивание сверху вниз
+    siftDown(0);
+    // Вернуть элемент с вершины кучи
+    return val;
+  }
+
+  /* Начиная с узла i, выполнить просеивание сверху вниз */
+  void siftDown(int i) {
+    while (true) {
+      // Определить узел с максимальным значением среди i, l и r и обозначить его как ma
+      int l = _left(i);
+      int r = _right(i);
+      int ma = i;
+      if (l < size() && _maxHeap[l] > _maxHeap[ma]) ma = l;
+      if (r < size() && _maxHeap[r] > _maxHeap[ma]) ma = r;
+      // Если узел i уже максимален или индексы l и r вне границ, дальнейшее просеивание не требуется, выйти
+      if (ma == i) break;
+      // Поменять два узла местами
+      _swap(i, ma);
+      // Циклическое просеивание вниз
+      i = ma;
+    }
+  }
+
+  /* Вывести кучу (двоичное дерево) */
+  void print() {
+    printHeap(_maxHeap);
+  }
+}
+
+/* Driver Code */
+void main() {
+  /* Инициализация максимальной кучи */
+  MaxHeap maxHeap = MaxHeap([9, 8, 6, 6, 7, 5, 2, 1, 4, 3, 6, 2]);
+  print("\nПосле построения кучи из входного списка");
+  maxHeap.print();
+
+  /* Получение элемента с вершины кучи */
+  int peek = maxHeap.peek();
+  print("\nЭлемент на вершине кучи = $peek");
+
+  /* Добавление элемента в кучу */
+  int val = 7;
+  maxHeap.push(val);
+  print("\nПосле добавления элемента $val в кучу");
+  maxHeap.print();
+
+  /* Извлечение элемента с вершины кучи */
+  peek = maxHeap.pop();
+  print("\nПосле извлечения элемента вершины кучи $peek");
+  maxHeap.print();
+
+  /* Получение размера кучи */
+  int size = maxHeap.size();
+  print("\nКоличество элементов в куче = $size");
+
+  /* Проверка, пуста ли куча */
+  bool isEmpty = maxHeap.isEmpty();
+  print("\nПуста ли куча: $isEmpty");
+}

ru/codes/dart/chapter_heap/top_k.dart

@@ -0,0 +1,150 @@
+/**
+ * File: top_k.dart
+ * Created Time: 2023-08-15
+ * Author: liuyuxin (gvenusleo@gmail.com)
+ */
+
+import '../utils/print_util.dart';
+
+/* Найти k наибольших элементов массива с помощью кучи */
+MinHeap topKHeap(List<int> nums, int k) {
+  // Инициализировать минимальную кучу, поместив в нее первые k элементов массива
+  MinHeap heap = MinHeap(nums.sublist(0, k));
+  // Начиная с элемента k+1, поддерживать длину кучи равной k
+  for (int i = k; i < nums.length; i++) {
+    // Если текущий элемент больше элемента на вершине кучи, извлечь вершину кучи и добавить текущий элемент в кучу
+    if (nums[i] > heap.peek()) {
+      heap.pop();
+      heap.push(nums[i]);
+    }
+  }
+  return heap;
+}
+
+/* Driver Code */
+void main() {
+  List<int> nums = [1, 7, 6, 3, 2];
+  int k = 3;
+
+  MinHeap res = topKHeap(nums, k);
+  print("Наибольшие $k элементов");
+  res.print();
+}
+
+/* Минимальная куча */
+class MinHeap {
+  late List<int> _minHeap;
+
+  /* Конструктор, строящий кучу по входному списку */
+  MinHeap(List<int> nums) {
+    // Добавить элементы списка в кучу без изменений
+    _minHeap = nums;
+    // Выполнить heapify для всех узлов, кроме листовых
+    for (int i = _parent(size() - 1); i >= 0; i--) {
+      siftDown(i);
+    }
+  }
+
+  /* Вернуть элементы в куче */
+  List<int> getHeap() {
+    return _minHeap;
+  }
+
+  /* Получить индекс левого дочернего узла */
+  int _left(int i) {
+    return 2 * i + 1;
+  }
+
+  /* Получить индекс правого дочернего узла */
+  int _right(int i) {
+    return 2 * i + 2;
+  }
+
+  /* Получить индекс родительского узла */
+  int _parent(int i) {
+    return (i - 1) ~/ 2; // Округление вниз при делении
+  }
+
+  /* Поменять элементы местами */
+  void _swap(int i, int j) {
+    int tmp = _minHeap[i];
+    _minHeap[i] = _minHeap[j];
+    _minHeap[j] = tmp;
+  }
+
+  /* Получение размера кучи */
+  int size() {
+    return _minHeap.length;
+  }
+
+  /* Проверка, пуста ли куча */
+  bool isEmpty() {
+    return size() == 0;
+  }
+
+  /* Доступ к элементу на вершине кучи */
+  int peek() {
+    return _minHeap[0];
+  }
+
+  /* Добавление элемента в кучу */
+  void push(int val) {
+    // Добавление узла
+    _minHeap.add(val);
+    // Просеивание снизу вверх
+    siftUp(size() - 1);
+  }
+
+  /* Начиная с узла i, выполнить просеивание снизу вверх */
+  void siftUp(int i) {
+    while (true) {
+      // Получение родительского узла для узла i
+      int p = _parent(i);
+      // Завершить heapify, когда «корневой узел уже пройден» или «узел не требует исправления»
+      if (p < 0 || _minHeap[i] >= _minHeap[p]) {
+        break;
+      }
+      // Поменять два узла местами
+      _swap(i, p);
+      // Циклическое просеивание вверх
+      i = p;
+    }
+  }
+
+  /* Извлечение элемента из кучи */
+  int pop() {
+    // Обработка пустого случая
+    if (isEmpty()) throw Exception('куча пуста');
+    // Поменять корневой узел с самым правым листом местами (поменять первый и последний элементы)
+    _swap(0, size() - 1);
+    // Удаление узла
+    int val = _minHeap.removeLast();
+    // Просеивание сверху вниз
+    siftDown(0);
+    // Вернуть элемент с вершины кучи
+    return val;
+  }
+
+  /* Начиная с узла i, выполнить просеивание сверху вниз */
+  void siftDown(int i) {
+    while (true) {
+      // Определить узел с максимальным значением среди i, l и r и обозначить его как ma
+      int l = _left(i);
+      int r = _right(i);
+      int mi = i;
+      if (l < size() && _minHeap[l] < _minHeap[mi]) mi = l;
+      if (r < size() && _minHeap[r] < _minHeap[mi]) mi = r;
+      // Если узел i уже максимален или индексы l и r вне границ, дальнейшее просеивание не требуется, выйти
+      if (mi == i) break;
+      // Поменять два узла местами
+      _swap(i, mi);
+      // Циклическое просеивание вниз
+      i = mi;
+    }
+  }
+
+  /* Вывести кучу (двоичное дерево) */
+  void print() {
+    printHeap(_minHeap);
+  }
+}

ru/codes/dart/chapter_searching/binary_search.dart

@@ -0,0 +1,63 @@
+/**
+ * File: binary_search.dart
+ * Created Time: 2023-05-12
+ * Author: Jefferson (JeffersonHuang77@gmail.com)
+ */
+
+/* Бинарный поиск (двусторонне замкнутый интервал) */
+int binarySearch(List<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(List<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;
+}
+
+/* Driver Code*/
+void main() {
+  int target = 6;
+  final nums = [1, 3, 6, 8, 12, 15, 23, 26, 31, 35];
+
+  /* Бинарный поиск (двусторонне замкнутый интервал) */
+  int index = binarySearch(nums, target);
+  print('Индекс целевого элемента 6 = $index');
+
+  /* Бинарный поиск (лево замкнутый, право открытый интервал) */
+  index = binarySearchLCRO(nums, target);
+  print('Индекс целевого элемента 6 = $index');
+}

ru/codes/dart/chapter_searching/binary_search_edge.dart

@@ -0,0 +1,48 @@
+/**
+ * File: binary_search_edge.dart
+ * Created Time: 2023-08-14
+ * Author: liuyuxin (gvenusleo@gmail.com)
+ */
+
+import 'binary_search_insertion.dart';
+
+/* Бинарный поиск самого левого target */
+int binarySearchLeftEdge(List<int> nums, int target) {
+  // Эквивалентно поиску точки вставки target
+  int i = binarySearchInsertion(nums, target);
+  // target не найден, вернуть -1
+  if (i == nums.length || nums[i] != target) {
+    return -1;
+  }
+  // Найти target и вернуть индекс i
+  return i;
+}
+
+/* Бинарный поиск самого правого target */
+int binarySearchRightEdge(List<int> nums, int target) {
+  // Преобразовать задачу в поиск самого левого target + 1
+  int i = 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;
+}
+
+/* Driver Code */
+void main() {
+  // Массив с повторяющимися элементами
+  List<int> nums = [1, 3, 6, 6, 6, 6, 6, 10, 12, 15];
+  print("\nМассив nums = $nums");
+
+  // Бинарный поиск левой и правой границы
+  for (int target in [6, 7]) {
+    int index = binarySearchLeftEdge(nums, target);
+    print("Индекс самого левого элемента $target равен $index");
+    index = binarySearchRightEdge(nums, target);
+    print("Индекс самого правого элемента $target равен $index");
+  }
+}

ru/codes/dart/chapter_searching/binary_search_insertion.dart

@@ -0,0 +1,60 @@
+/**
+ * File: binary_search_insertion.dart
+ * Created Time: 2023-08-14
+ * Author: liuyuxin (gvenusleo@gmail.com)
+ */
+
+/* Бинарный поиск точки вставки (без повторяющихся элементов) */
+int binarySearchInsertionSimple(List<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;
+}
+
+/* Бинарный поиск точки вставки (с повторяющимися элементами) */
+int binarySearchInsertion(List<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;
+}
+
+/* Driver Code */
+void main() {
+  // Массив без повторяющихся элементов
+  List<int> nums = [1, 3, 6, 8, 12, 15, 23, 26, 31, 35];
+  print("\nМассив nums = $nums");
+  // Бинарный поиск точки вставки
+  for (int target in [6, 9]) {
+    int index = binarySearchInsertionSimple(nums, target);
+    print("Индекс позиции вставки элемента $target равен $index");
+  }
+
+  // Массив с повторяющимися элементами
+  nums = [1, 3, 6, 6, 6, 6, 6, 10, 12, 15];
+  print("\nМассив nums = $nums");
+  // Бинарный поиск точки вставки
+  for (int target in [2, 6, 20]) {
+    int index = binarySearchInsertion(nums, target);
+    print("Индекс позиции вставки элемента $target равен $index");
+  }
+}

ru/codes/dart/chapter_searching/hashing_search.dart

@@ -0,0 +1,54 @@
+/**
+ * File: hashing_search.dart
+ * Created Time: 2023-05-12
+ * Author: Jefferson (JeffersonHuang77@gmail.com)
+ */
+
+import 'dart:collection';
+import '../utils/list_node.dart';
+
+/* Хеш-поиск (массив) */
+int hashingSearchArray(Map<int, int> map, int target) {
+  // key хеш-таблицы: целевой элемент, value: индекс
+  // Если такого key нет в хеш-таблице, вернуть -1
+  if (!map.containsKey(target)) {
+    return -1;
+  }
+  return map[target]!;
+}
+
+/* Хеш-поиск (связный список) */
+ListNode? hashingSearchLinkedList(Map<int, ListNode> map, int target) {
+  // key хеш-таблицы: значение целевого узла, value: объект узла
+  // Если такого key нет в хеш-таблице, вернуть null
+  if (!map.containsKey(target)) {
+    return null;
+  }
+  return map[target]!;
+}
+
+/* Driver Code */
+void main() {
+  int target = 3;
+
+  /* Хеш-поиск (массив) */
+  List<int> nums = [1, 5, 3, 2, 4, 7, 5, 9, 10, 8];
+  // Инициализация хеш-таблицы
+  Map<int, int> map = HashMap();
+  for (int i = 0; i < nums.length; i++) {
+    map.putIfAbsent(nums[i], () => i); // key: элемент, value: индекс
+  }
+  int index = hashingSearchArray(map, target);
+  print('Индекс целевого элемента 3 = $index');
+
+  /* Хеш-поиск (связный список) */
+  ListNode? head = listToLinkedList(nums);
+  // Инициализация хеш-таблицы
+  Map<int, ListNode> map1 = HashMap();
+  while (head != null) {
+    map1.putIfAbsent(head.val, () => head!); // key: значение узла, value: узел
+    head = head.next;
+  }
+  ListNode? node = hashingSearchLinkedList(map1, target);
+  print('Объект узла со значением 3 = $node');
+}

ru/codes/dart/chapter_searching/linear_search.dart

@@ -0,0 +1,47 @@
+/**
+ * File: linear_search.dart
+ * Created Time: 2023-05-12
+ * Author: Jefferson (JeffersonHuang77@gmail.com)
+ */
+
+import '../utils/list_node.dart';
+
+/* Линейный поиск (массив) */
+int linearSearchArray(List<int> nums, int target) {
+  // Обход массива
+  for (int i = 0; i < nums.length; i++) {
+    // Целевой элемент найден, вернуть его индекс
+    if (nums[i] == target) {
+      return i;
+    }
+  }
+  // Целевой элемент не найден, вернуть -1
+  return -1;
+}
+
+/* Линейный поиск (связный список) */
+ListNode? linearSearchList(ListNode? head, int target) {
+  // Обойти связный список
+  while (head != null) {
+    // Найти целевой узел и вернуть его
+    if (head.val == target) return head;
+    head = head.next;
+  }
+  // Целевой элемент не найден, вернуть null
+  return null;
+}
+
+/* Driver Code */
+void main() {
+  int target = 3;
+
+  /* Выполнить линейный поиск в массиве */
+  List<int> nums = [1, 5, 3, 2, 4, 7, 5, 9, 10, 8];
+  int index = linearSearchArray(nums, target);
+  print('Индекс целевого элемента 3 = $index');
+
+  /* Выполнить линейный поиск в связном списке */
+  ListNode? head = listToLinkedList(nums);
+  ListNode? node = linearSearchList(head, target);
+  print('Объект узла со значением 3 = $node');
+}

ru/codes/dart/chapter_searching/two_sum.dart

@@ -0,0 +1,49 @@
+/**
+ * File: two_sum.dart
+ * Created Time: 2023-2-11
+ * Author: Jefferson (JeffersonHuang77@gmail.com)
+ */
+
+import 'dart:collection';
+
+/* Способ 1: полный перебор */
+List<int> twoSumBruteForce(List<int> nums, int target) {
+  int size = nums.length;
+  // Два вложенных цикла, временная сложность O(n^2)
+  for (var i = 0; i < size - 1; i++) {
+    for (var j = i + 1; j < size; j++) {
+      if (nums[i] + nums[j] == target) return [i, j];
+    }
+  }
+  return [0];
+}
+
+/* Способ 2: вспомогательная хеш-таблица */
+List<int> twoSumHashTable(List<int> nums, int target) {
+  int size = nums.length;
+  // Вспомогательная хеш-таблица, пространственная сложность O(n)
+  Map<int, int> dic = HashMap();
+  // Один цикл, временная сложность O(n)
+  for (var i = 0; i < size; i++) {
+    if (dic.containsKey(target - nums[i])) {
+      return [dic[target - nums[i]]!, i];
+    }
+    dic.putIfAbsent(nums[i], () => i);
+  }
+  return [0];
+}
+
+/* Driver Code */
+void main() {
+  // ======= Test Case =======
+  List<int> nums = [2, 7, 11, 15];
+  int target = 13;
+
+  // ====== Основной код ======
+  // Метод 1
+  List<int> res = twoSumBruteForce(nums, target);
+  print('Результат метода 1 res = $res');
+  // Метод 2
+  res = twoSumHashTable(nums, target);
+  print('Результат метода 2 res = $res');
+}

ru/codes/dart/chapter_sorting/bubble_sort.dart

@@ -0,0 +1,51 @@
+/**
+ * File: bubble_sort.dart
+ * Created Time: 2023-02-14
+ * Author: what-is-me (whatisme@outlook.jp)
+ */
+
+/* Пузырьковая сортировка */
+void bubbleSort(List<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]
+        int tmp = nums[j];
+        nums[j] = nums[j + 1];
+        nums[j + 1] = tmp;
+      }
+    }
+  }
+}
+
+/* Пузырьковая сортировка (оптимизация флагом) */
+void bubbleSortWithFlag(List<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]
+        int tmp = nums[j];
+        nums[j] = nums[j + 1];
+        nums[j + 1] = tmp;
+        flag = true; // Записать обмен элементов
+      }
+    }
+    if (!flag) break; // На этой итерации «всплытия» не было ни одного обмена, сразу выйти
+  }
+}
+
+/* Driver Code */
+void main() {
+  List<int> nums = [4, 1, 3, 1, 5, 2];
+  bubbleSort(nums);
+  print("После пузырьковой сортировки nums = $nums");
+
+  List<int> nums1 = [4, 1, 3, 1, 5, 2];
+  bubbleSortWithFlag(nums1);
+  print("После пузырьковой сортировки nums1 = $nums1");
+}

ru/codes/dart/chapter_sorting/bucket_sort.dart

@@ -0,0 +1,39 @@
+/**
+ * File: bucket_sort.dart
+ * Created Time: 2023-05-12
+ * Author: Jefferson (JeffersonHuang77@gmail.com)
+ */
+
+/* Сортировка корзинами */
+void bucketSort(List<double> nums) {
+  // Инициализировать k = n/2 корзин, предполагая распределение 2 элементов в каждую корзину
+  int k = nums.length ~/ 2;
+  List<List<double>> buckets = List.generate(k, (index) => []);
+
+  // 1. Распределить элементы массива по корзинам
+  for (double _num in nums) {
+    // Входные данные находятся в диапазоне [0, 1), используем _num * k для отображения в диапазон индексов [0, k-1]
+    int i = (_num * k).toInt();
+    // Добавить _num в корзину bucket_idx
+    buckets[i].add(_num);
+  }
+  // 2. Выполнить сортировку внутри каждой корзины
+  for (List<double> bucket in buckets) {
+    bucket.sort();
+  }
+  // 3. Обойти корзины и объединить результаты
+  int i = 0;
+  for (List<double> bucket in buckets) {
+    for (double _num in bucket) {
+      nums[i++] = _num;
+    }
+  }
+}
+
+/* Driver Code*/
+void main() {
+  // Пусть входные данные — числа с плавающей точкой из диапазона [0, 1)
+  final nums = [0.49, 0.96, 0.82, 0.09, 0.57, 0.43, 0.91, 0.75, 0.15, 0.37];
+  bucketSort(nums);
+  print('После сортировки корзинами nums = $nums');
+}

ru/codes/dart/chapter_sorting/counting_sort.dart

@@ -0,0 +1,72 @@
+/**
+ * File: counting_sort.dart
+ * Created Time: 2023-05-12
+ * Author: Jefferson (JeffersonHuang77@gmail.com)
+ */
+import 'dart:math';
+
+/* Сортировка подсчетом */
+// Простая реализация, не подходит для сортировки объектов
+void countingSortNaive(List<int> nums) {
+  // 1. Найти максимальный элемент массива m
+  int m = 0;
+  for (int _num in nums) {
+    m = max(m, _num);
+  }
+  // 2. Подсчитать число появлений каждой цифры
+  // counter[_num] обозначает число появлений _num
+  List<int> counter = List.filled(m + 1, 0);
+  for (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(List<int> nums) {
+  // 1. Найти максимальный элемент массива m
+  int m = 0;
+  for (int _num in nums) {
+    m = max(m, _num);
+  }
+  // 2. Подсчитать число появлений каждой цифры
+  // counter[_num] обозначает число появлений _num
+  List<int> counter = List.filled(m + 1, 0);
+  for (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;
+  List<int> res = List.filled(n, 0);
+  for (int i = n - 1; i >= 0; i--) {
+    int _num = nums[i];
+    res[counter[_num] - 1] = _num; // Поместить _num по соответствующему индексу
+    counter[_num]--; // Уменьшить префиксную сумму на 1, чтобы получить индекс следующего размещения _num
+  }
+  // Перезаписать исходный массив nums массивом результата res
+  nums.setAll(0, res);
+}
+
+/* Driver Code*/
+void main() {
+  final nums = [1, 0, 1, 2, 0, 4, 0, 2, 2, 4];
+  countingSortNaive(nums);
+  print('После сортировки подсчетом (объекты не поддерживаются) nums = $nums');
+
+  final nums1 = [1, 0, 1, 2, 0, 4, 0, 2, 2, 4];
+  countingSort(nums1);
+  print('После сортировки подсчетом nums1 = $nums1');
+}

ru/codes/dart/chapter_sorting/heap_sort.dart

@@ -0,0 +1,49 @@
+/**
+ * File: heap_sort.dart
+ * Created Time: 2023-06-01
+ * Author: liuyuxin (gvenusleo@gmail.com)
+ */
+
+/* Длина кучи равна n; начиная с узла i, выполнить просеивание сверху вниз */
+void siftDown(List<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;
+    // Поменять два узла местами
+    int temp = nums[i];
+    nums[i] = nums[ma];
+    nums[ma] = temp;
+    // Циклическое просеивание вниз
+    i = ma;
+  }
+}
+
+/* Сортировка кучей */
+void heapSort(List<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--) {
+    // Поменять корневой узел с самым правым листом местами (поменять первый и последний элементы)
+    int tmp = nums[0];
+    nums[0] = nums[i];
+    nums[i] = tmp;
+    // Начиная с корневого узла, выполнить просеивание сверху вниз
+    siftDown(nums, i, 0);
+  }
+}
+
+/* Driver Code */
+void main() {
+  List<int> nums = [4, 1, 3, 1, 5, 2];
+  heapSort(nums);
+  print("После сортировки кучей nums = $nums");
+}

ru/codes/dart/chapter_sorting/insertion_sort.dart

@@ -0,0 +1,26 @@
+/**
+ * File: insertion_sort.dart
+ * Created Time: 2023-02-14
+ * Author: what-is-me (whatisme@outlook.jp)
+ */
+
+/* Сортировка вставками */
+void insertionSort(List<int> nums) {
+  // Внешний цикл: отсортированный диапазон [0, i-1]
+  for (int i = 1; i < nums.length; i++) {
+    int base = nums[i], j = i - 1;
+    // Внутренний цикл: вставить base в правильную позицию отсортированного диапазона [0, i-1]
+    while (j >= 0 && nums[j] > base) {
+      nums[j + 1] = nums[j]; // Сдвинуть nums[j] на одну позицию вправо
+      j--;
+    }
+    nums[j + 1] = base; // Поместить base в правильную позицию
+  }
+}
+
+/* Driver Code */
+void main() {
+  List<int> nums = [4, 1, 3, 1, 5, 2];
+  insertionSort(nums);
+  print("После сортировки вставками nums = $nums");
+}

ru/codes/dart/chapter_sorting/merge_sort.dart

@@ -0,0 +1,52 @@
+/**
+ * File: merge_sort.dart
+ * Created Time: 2023-02-14
+ * Author: what-is-me (whatisme@outlook.jp)
+ */
+
+/* Объединить левый и правый подмассивы */
+void merge(List<int> nums, int left, int mid, int right) {
+  // Диапазон левого подмассива: [left, mid], диапазон правого подмассива: [mid+1, right]
+  // Создать временный массив tmp для хранения результата слияния
+  List<int> tmp = List.filled(right - left + 1, 0);
+  // Инициализировать начальные индексы левого и правого подмассивов
+  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(List<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);
+}
+
+/* Driver Code */
+void main() {
+  /* Сортировка слиянием */
+  List<int> nums = [7, 3, 2, 6, 0, 1, 5, 4];
+  mergeSort(nums, 0, nums.length - 1);
+  print("После сортировки слиянием nums = $nums");
+}

ru/codes/dart/chapter_sorting/quick_sort.dart

@@ -0,0 +1,145 @@
+/**
+ * File: quick_sort.dart
+ * Created Time: 2023-02-14
+ * Author: what-is-me (whatisme@outlook.jp)
+ */
+
+/* Класс быстрой сортировки */
+class QuickSort {
+  /* Обмен элементов */
+  static void _swap(List<int> nums, int i, int j) {
+    int tmp = nums[i];
+    nums[i] = nums[j];
+    nums[j] = tmp;
+  }
+
+  /* Разбиение с опорными указателями */
+  static int _partition(List<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; // Вернуть индекс опорного элемента
+  }
+
+  /* Быстрая сортировка */
+  static void quickSort(List<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(List<int> nums, int i, int j) {
+    int tmp = nums[i];
+    nums[i] = nums[j];
+    nums[j] = tmp;
+  }
+
+  /* Выбрать медиану из трех кандидатов */
+  static int _medianThree(List<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(List<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; // Вернуть индекс опорного элемента
+  }
+
+  /* Быстрая сортировка */
+  static void quickSort(List<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(List<int> nums, int i, int j) {
+    int tmp = nums[i];
+    nums[i] = nums[j];
+    nums[j] = tmp;
+  }
+
+  /* Разбиение с опорными указателями */
+  static int _partition(List<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; // Вернуть индекс опорного элемента
+  }
+
+  /* Быстрая сортировка (оптимизация глубины рекурсии) */
+  static void quickSort(List<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]
+      }
+    }
+  }
+}
+
+/* Driver Code */
+void main() {
+  /* Быстрая сортировка */
+  List<int> nums = [2, 4, 1, 0, 3, 5];
+  QuickSort.quickSort(nums, 0, nums.length - 1);
+  print("После быстрой сортировки nums = $nums");
+
+  /* Быстрая сортировка (оптимизация медианным опорным элементом) */
+  List<int> nums1 = [2, 4, 1, 0, 3, 5];
+  QuickSortMedian.quickSort(nums1, 0, nums1.length - 1);
+  print("После быстрой сортировки (оптимизация медианным опорным элементом) nums1 = $nums1");
+
+  /* Быстрая сортировка (оптимизация глубины рекурсии) */
+  List<int> nums2 = [2, 4, 1, 0, 3, 5];
+  QuickSortTailCall.quickSort(nums2, 0, nums2.length - 1);
+  print("После быстрой сортировки (оптимизация глубины рекурсии) nums2 = $nums2");
+}

ru/codes/dart/chapter_sorting/radix_sort.dart

@@ -0,0 +1,71 @@
+/**
+ * File: radix_sort.dart
+ * Created Time: 2023-02-14
+ * Author: what-is-me (whatisme@outlook.jp)
+ */
+
+/* Получить k-й разряд элемента _num, где exp = 10^(k-1) */
+int digit(int _num, int exp) {
+  // Передача exp вместо k позволяет избежать повторного дорогостоящего вычисления степени
+  return (_num ~/ exp) % 10;
+}
+
+/* Сортировка подсчетом (сортировка по k-му разряду nums) */
+void countingSortDigit(List<int> nums, int exp) {
+  // Разряды десятичной системы лежат в диапазоне 0~9, поэтому нужен массив корзин длины 10
+  List<int> counter = List<int>.filled(10, 0);
+  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 элементами по статистике в корзинах
+  List<int> res = List<int>.filled(n, 0);
+  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(List<int> nums) {
+  // Получить максимальный элемент массива, чтобы определить максимальное число разрядов
+  // В dart длина int составляет 64 бита
+  int m = -1 << 63;
+  for (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);
+}
+
+/* Driver Code */
+void main() {
+  // Поразрядная сортировка
+  List<int> nums = [
+    10546151,
+    35663510,
+    42865989,
+    34862445,
+    81883077,
+    88906420,
+    72429244,
+    30524779,
+    82060337,
+    63832996
+  ];
+  radixSort(nums);
+  print("После поразрядной сортировки nums = $nums");
+}

ru/codes/dart/chapter_sorting/selection_sort.dart

@@ -0,0 +1,29 @@
+/**
+ * File: selection_sort.dart
+ * Created Time: 2023-06-01
+ * Author: liuyuxin (gvenusleo@gmail.com)
+ */
+
+/* Сортировка выбором */
+void selectionSort(List<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; // Записать индекс минимального элемента
+    }
+    // Поменять этот минимальный элемент местами с первым элементом неотсортированного диапазона
+    int temp = nums[i];
+    nums[i] = nums[k];
+    nums[k] = temp;
+  }
+}
+
+/* Driver Code */
+void main() {
+  List<int> nums = [4, 1, 3, 1, 5, 2];
+  selectionSort(nums);
+  print("После сортировки выбором nums = $nums");
+}

ru/codes/dart/chapter_stack_and_queue/array_deque.dart

@@ -0,0 +1,146 @@
+/**
+ * File: array_deque.dart
+ * Created Time: 2023-03-28
+ * Author: liuyuxin (gvenusleo@gmail.com)
+ */
+
+/* Двусторонняя очередь на основе кольцевого массива */
+class ArrayDeque {
+  late List<int> _nums; // Массив для хранения элементов двусторонней очереди
+  late int _front; // Указатель head, указывающий на первый элемент очереди
+  late int _queSize; // Длина двусторонней очереди
+
+  /* Конструктор */
+  ArrayDeque(int capacity) {
+    this._nums = List.filled(capacity, 0);
+    this._front = this._queSize = 0;
+  }
+
+  /* Получить вместимость двусторонней очереди */
+  int capacity() {
+    return _nums.length;
+  }
+
+  /* Получение длины двусторонней очереди */
+  int size() {
+    return _queSize;
+  }
+
+  /* Проверка, пуста ли двусторонняя очередь */
+  bool isEmpty() {
+    return _queSize == 0;
+  }
+
+  /* Вычислить индекс в кольцевом массиве */
+  int index(int i) {
+    // С помощью операции взятия по модулю соединить начало и конец массива
+    // Когда i выходит за конец массива, он возвращается в начало
+    // Когда i выходит за начало массива, он возвращается в конец
+    return (i + capacity()) % capacity();
+  }
+
+  /* Добавление в голову очереди */
+  void pushFirst(int _num) {
+    if (_queSize == capacity()) {
+      throw Exception("Двусторонняя очередь заполнена");
+    }
+    // Указатель головы сместить влево на одну позицию
+    // С помощью операции взятия остатка реализовать возврат _front к хвосту после выхода за начало массива
+    _front = index(_front - 1);
+    // Добавить _num в голову очереди
+    _nums[_front] = _num;
+    _queSize++;
+  }
+
+  /* Добавление в хвост очереди */
+  void pushLast(int _num) {
+    if (_queSize == capacity()) {
+      throw Exception("Двусторонняя очередь заполнена");
+    }
+    // Вычислить указатель хвоста, указывающий на индекс хвоста + 1
+    int rear = index(_front + _queSize);
+    // Добавить _num в хвост очереди
+    _nums[rear] = _num;
+    _queSize++;
+  }
+
+  /* Извлечение из головы очереди */
+  int popFirst() {
+    int _num = peekFirst();
+    // Указатель головы сместить вправо на одну позицию
+    _front = index(_front + 1);
+    _queSize--;
+    return _num;
+  }
+
+  /* Извлечение из хвоста очереди */
+  int popLast() {
+    int _num = peekLast();
+    _queSize--;
+    return _num;
+  }
+
+  /* Доступ к элементу в начале очереди */
+  int peekFirst() {
+    if (isEmpty()) {
+      throw Exception("двусторонняя очередь пуста");
+    }
+    return _nums[_front];
+  }
+
+  /* Доступ к элементу в конце очереди */
+  int peekLast() {
+    if (isEmpty()) {
+      throw Exception("двусторонняя очередь пуста");
+    }
+    // Вычислить индекс хвостового элемента
+    int last = index(_front + _queSize - 1);
+    return _nums[last];
+  }
+
+  /* Вернуть массив для вывода */
+  List<int> toArray() {
+    // Преобразовывать только элементы списка в пределах фактической длины
+    List<int> res = List.filled(_queSize, 0);
+    for (int i = 0, j = _front; i < _queSize; i++, j++) {
+      res[i] = _nums[index(j)];
+    }
+    return res;
+  }
+}
+
+/* Driver Code */
+void main() {
+  /* Инициализация двусторонней очереди */
+  final ArrayDeque deque = ArrayDeque(10);
+  deque.pushLast(3);
+  deque.pushLast(2);
+  deque.pushLast(5);
+  print("Двусторонняя очередь deque = ${deque.toArray()}");
+
+  /* Доступ к элементу */
+  final int peekFirst = deque.peekFirst();
+  print("Первый элемент peekFirst = $peekFirst");
+  final int peekLast = deque.peekLast();
+  print("Последний элемент peekLast = $peekLast");
+
+  /* Добавление элемента в очередь */
+  deque.pushLast(4);
+  print("После добавления элемента 4 в хвост deque = ${deque.toArray()}");
+  deque.pushFirst(1);
+  print("После добавления элемента 1 в голову deque = ${deque.toArray()}");
+
+  /* Извлечение элемента из очереди */
+  final int popLast = deque.popLast();
+  print("Извлеченный из хвоста элемент = $popLast, deque после извлечения из хвоста = ${deque.toArray()}");
+  final int popFirst = deque.popFirst();
+  print("Извлеченный из головы элемент = $popFirst, deque после извлечения из головы = ${deque.toArray()}");
+
+  /* Получение длины двусторонней очереди */
+  final int size = deque.size();
+  print("Длина двусторонней очереди size = $size");
+
+  /* Проверка, пуста ли двусторонняя очередь */
+  final bool isEmpty = deque.isEmpty();
+  print("Пуста ли двусторонняя очередь = $isEmpty");
+}

ru/codes/dart/chapter_stack_and_queue/array_queue.dart

@@ -0,0 +1,110 @@
+/**
+ * File: array_queue.dart
+ * Created Time: 2023-03-28
+ * Author: liuyuxin (gvenusleo@gmail.com)
+ */
+
+/* Очередь на основе кольцевого массива */
+class ArrayQueue {
+  late List<int> _nums; // Массив для хранения элементов очереди
+  late int _front; // Указатель head, указывающий на первый элемент очереди
+  late int _queSize; // Длина очереди
+
+  ArrayQueue(int capacity) {
+    _nums = List.filled(capacity, 0);
+    _front = _queSize = 0;
+  }
+
+  /* Получить вместимость очереди */
+  int capaCity() {
+    return _nums.length;
+  }
+
+  /* Получение длины очереди */
+  int size() {
+    return _queSize;
+  }
+
+  /* Проверка, пуста ли очередь */
+  bool isEmpty() {
+    return _queSize == 0;
+  }
+
+  /* Поместить в очередь */
+  void push(int _num) {
+    if (_queSize == capaCity()) {
+      throw Exception("Очередь заполнена");
+    }
+    // Вычислить указатель хвоста, указывающий на индекс хвоста + 1
+    // С помощью операции взятия по модулю вернуть rear к началу после выхода за конец массива
+    int rear = (_front + _queSize) % capaCity();
+    // Добавить _num в хвост очереди
+    _nums[rear] = _num;
+    _queSize++;
+  }
+
+  /* Извлечь из очереди */
+  int pop() {
+    int _num = peek();
+    // Указатель head сдвигается на одну позицию назад; если он выходит за конец, то возвращается в начало массива
+    _front = (_front + 1) % capaCity();
+    _queSize--;
+    return _num;
+  }
+
+  /* Доступ к элементу в начале очереди */
+  int peek() {
+    if (isEmpty()) {
+      throw Exception("очередь пуста");
+    }
+    return _nums[_front];
+  }
+
+  /* Вернуть Array */
+  List<int> toArray() {
+    // Преобразовывать только элементы списка в пределах фактической длины
+    final List<int> res = List.filled(_queSize, 0);
+    for (int i = 0, j = _front; i < _queSize; i++, j++) {
+      res[i] = _nums[j % capaCity()];
+    }
+    return res;
+  }
+}
+
+/* Driver Code */
+void main() {
+  /* Инициализация очереди */
+  final int capacity = 10;
+  final ArrayQueue queue = ArrayQueue(capacity);
+
+  /* Добавление элемента в очередь */
+  queue.push(1);
+  queue.push(3);
+  queue.push(2);
+  queue.push(5);
+  queue.push(4);
+  print("Очередь queue = ${queue.toArray()}");
+
+  /* Доступ к элементу в начале очереди */
+  final int peek = queue.peek();
+  print("Первый элемент peek = $peek");
+
+  /* Извлечение элемента из очереди */
+  final int pop = queue.pop();
+  print("Извлеченный элемент pop = $pop, queue после извлечения = ${queue.toArray()}");
+
+  /* Получить длину очереди */
+  final int size = queue.size();
+  print("Длина очереди size = $size");
+
+  /* Проверка, пуста ли очередь */
+  final bool isEmpty = queue.isEmpty();
+  print("Пуста ли очередь = $isEmpty");
+
+  /* Проверка кольцевого массива */
+  for (int i = 0; i < 10; i++) {
+    queue.push(i);
+    queue.pop();
+    print("После $i-го раунда операций enqueue и dequeue queue = ${queue.toArray()}");
+  }
+}

ru/codes/dart/chapter_stack_and_queue/array_stack.dart

@@ -0,0 +1,77 @@
+/**
+ * File: array_stack.dart
+ * Created Time: 2023-03-28
+ * Author: liuyuxin (gvenusleo@gmail.com)
+ */
+
+/* Стек на основе массива */
+class ArrayStack {
+  late List<int> _stack;
+  ArrayStack() {
+    _stack = [];
+  }
+
+  /* Получение длины стека */
+  int size() {
+    return _stack.length;
+  }
+
+  /* Проверка, пуст ли стек */
+  bool isEmpty() {
+    return _stack.isEmpty;
+  }
+
+  /* Поместить в стек */
+  void push(int _num) {
+    _stack.add(_num);
+  }
+
+  /* Извлечь из стека */
+  int pop() {
+    if (isEmpty()) {
+      throw Exception("стек пуст");
+    }
+    return _stack.removeLast();
+  }
+
+  /* Доступ к верхнему элементу стека */
+  int peek() {
+    if (isEmpty()) {
+      throw Exception("стек пуст");
+    }
+    return _stack.last;
+  }
+
+  /* Преобразовать стек в Array и вернуть */
+  List<int> toArray() => _stack;
+}
+
+/* Driver Code */
+void main() {
+  /* Инициализация стека */
+  final ArrayStack stack = ArrayStack();
+
+  /* Помещение элемента в стек */
+  stack.push(1);
+  stack.push(3);
+  stack.push(2);
+  stack.push(5);
+  stack.push(4);
+  print("Стек stack = ${stack.toArray()}");
+
+  /* Доступ к верхнему элементу стека */
+  final int peek = stack.peek();
+  print("Верхний элемент peek = $peek");
+
+  /* Извлечение элемента из стека */
+  final int pop = stack.pop();
+  print("Извлеченный элемент pop = $pop, stack после извлечения = ${stack.toArray()}");
+
+  /* Получение длины стека */
+  final int size = stack.size();
+  print("Длина стека size = $size");
+
+  /* Проверка на пустоту */
+  final bool isEmpty = stack.isEmpty();
+  print("Пуст ли стек = $isEmpty");
+}

ru/codes/dart/chapter_stack_and_queue/deque.dart

@@ -0,0 +1,42 @@
+/**
+ * File: deque.dart
+ * Created Time: 2023-03-28
+ * Author: liuyuxin (gvenusleo@gmail.com)
+ */
+
+import 'dart:collection';
+
+void main() {
+  /* Инициализация двусторонней очереди */
+  final Queue<int> deque = Queue();
+  deque.addFirst(3);
+  deque.addLast(2);
+  deque.addLast(5);
+  print("Двусторонняя очередь deque = $deque");
+
+  /* Доступ к элементу */
+  final int peekFirst = deque.first;
+  print("Первый элемент peekFirst = $peekFirst");
+  final int peekLast = deque.last;
+  print("Последний элемент peekLast = $peekLast");
+
+  /* Добавление элемента в очередь */
+  deque.addLast(4);
+  print("После добавления элемента 4 в хвост deque = $deque");
+  deque.addFirst(1);
+  print("После добавления элемента 1 в голову deque = $deque");
+
+  /* Извлечение элемента из очереди */
+  final int popLast = deque.removeLast();
+  print("Извлеченный из хвоста элемент = $popLast, deque после извлечения из хвоста = $deque");
+  final int popFirst = deque.removeFirst();
+  print("Извлеченный из головы элемент = $popFirst, deque после извлечения из головы = $deque");
+
+  /* Получение длины двусторонней очереди */
+  final int size = deque.length;
+  print("Длина двусторонней очереди size = $size");
+
+  /* Проверка, пуста ли двусторонняя очередь */
+  final bool isEmpty = deque.isEmpty;
+  print("Пуста ли двусторонняя очередь = $isEmpty");
+}

ru/codes/dart/chapter_stack_and_queue/linkedlist_deque.dart

@@ -0,0 +1,167 @@
+/**
+ * File: linkedlist_deque.dart
+ * Created Time: 2023-03-28
+ * Author: liuyuxin (gvenusleo@gmail.com)
+ */
+
+/* Узел двусвязного списка */
+class ListNode {
+  int val; // Значение узла
+  ListNode? next; // Ссылка на узел-преемник
+  ListNode? prev; // Ссылка на узел-предшественник
+
+  ListNode(this.val, {this.next, this.prev});
+}
+
+/* Двусторонняя очередь на основе двусвязного списка */
+class LinkedListDeque {
+  late ListNode? _front; // Головной узел _front
+  late ListNode? _rear; // Хвостовой узел _rear
+  int _queSize = 0; // Длина двусторонней очереди
+
+  LinkedListDeque() {
+    this._front = null;
+    this._rear = null;
+  }
+
+  /* Получить длину двусторонней очереди */
+  int size() {
+    return this._queSize;
+  }
+
+  /* Проверка, пуста ли двусторонняя очередь */
+  bool isEmpty() {
+    return size() == 0;
+  }
+
+  /* Операция добавления в очередь */
+  void push(int _num, bool isFront) {
+    final ListNode node = ListNode(_num);
+    if (isEmpty()) {
+      // Если связный список пуст, пусть _front и _rear оба указывают на node
+      _front = _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++; // Обновить длину очереди
+  }
+
+  /* Добавление в голову очереди */
+  void pushFirst(int _num) {
+    push(_num, true);
+  }
+
+  /* Добавление в хвост очереди */
+  void pushLast(int _num) {
+    push(_num, false);
+  }
+
+  /* Операция извлечения из очереди */
+  int? pop(bool isFront) {
+    // Если очередь пуста, сразу вернуть null
+    if (isEmpty()) {
+      return null;
+    }
+    final 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;
+  }
+
+  /* Извлечение из головы очереди */
+  int? popFirst() {
+    return pop(true);
+  }
+
+  /* Извлечение из хвоста очереди */
+  int? popLast() {
+    return pop(false);
+  }
+
+  /* Доступ к элементу в начале очереди */
+  int? peekFirst() {
+    return _front?.val;
+  }
+
+  /* Доступ к элементу в конце очереди */
+  int? peekLast() {
+    return _rear?.val;
+  }
+
+  /* Вернуть массив для вывода */
+  List<int> toArray() {
+    ListNode? node = _front;
+    final List<int> res = [];
+    for (int i = 0; i < _queSize; i++) {
+      res.add(node!.val);
+      node = node.next;
+    }
+    return res;
+  }
+}
+
+/* Driver Code */
+void main() {
+  /* Инициализация двусторонней очереди */
+  final LinkedListDeque deque = LinkedListDeque();
+  deque.pushLast(3);
+  deque.pushLast(2);
+  deque.pushLast(5);
+  print("Двусторонняя очередь deque = ${deque.toArray()}");
+
+  /* Доступ к элементу */
+  int? peekFirst = deque.peekFirst();
+  print("Первый элемент peekFirst = $peekFirst");
+  int? peekLast = deque.peekLast();
+  print("Последний элемент peekLast = $peekLast");
+
+  /* Добавление элемента в очередь */
+  deque.pushLast(4);
+  print("После добавления элемента 4 в хвост deque = ${deque.toArray()}");
+  deque.pushFirst(1);
+  print("После добавления элемента 1 в голову deque = ${deque.toArray()}");
+
+  /* Извлечение элемента из очереди */
+  int? popLast = deque.popLast();
+  print("Извлеченный из хвоста элемент = $popLast, deque после извлечения из хвоста = ${deque.toArray()}");
+  int? popFirst = deque.popFirst();
+  print("Извлеченный из головы элемент = $popFirst, deque после извлечения из головы = ${deque.toArray()}");
+
+  /* Получение длины двусторонней очереди */
+  int size = deque.size();
+  print("Длина двусторонней очереди size = $size");
+
+  /* Проверка, пуста ли двусторонняя очередь */
+  bool isEmpty = deque.isEmpty();
+  print("Пуста ли двусторонняя очередь = $isEmpty");
+}

ru/codes/dart/chapter_stack_and_queue/linkedlist_queue.dart

@@ -0,0 +1,103 @@
+/**
+ * File: linkedlist_queue.dart
+ * Created Time: 2023-03-28
+ * Author: liuyuxin (gvenusleo@gmail.com)
+ */
+
+import '../utils/list_node.dart';
+
+/* Очередь на основе связного списка */
+class LinkedListQueue {
+  ListNode? _front; // Головной узел _front
+  ListNode? _rear; // Хвостовой узел _rear
+  int _queSize = 0; // Длина очереди
+
+  LinkedListQueue() {
+    _front = null;
+    _rear = null;
+  }
+
+  /* Получение длины очереди */
+  int size() {
+    return _queSize;
+  }
+
+  /* Проверка, пуста ли очередь */
+  bool isEmpty() {
+    return _queSize == 0;
+  }
+
+  /* Поместить в очередь */
+  void push(int _num) {
+    // Добавить _num после хвостового узла
+    final node = ListNode(_num);
+    // Если очередь пуста, сделать так, чтобы и head, и tail указывали на этот узел
+    if (_front == null) {
+      _front = node;
+      _rear = node;
+    } else {
+      // Если очередь не пуста, добавить этот узел после хвостового узла
+      _rear!.next = node;
+      _rear = node;
+    }
+    _queSize++;
+  }
+
+  /* Извлечь из очереди */
+  int pop() {
+    final int _num = peek();
+    // Удалить головной узел
+    _front = _front!.next;
+    _queSize--;
+    return _num;
+  }
+
+  /* Доступ к элементу в начале очереди */
+  int peek() {
+    if (_queSize == 0) {
+      throw Exception('очередь пуста');
+    }
+    return _front!.val;
+  }
+
+  /* Преобразовать связный список в Array и вернуть */
+  List<int> toArray() {
+    ListNode? node = _front;
+    final List<int> queue = [];
+    while (node != null) {
+      queue.add(node.val);
+      node = node.next;
+    }
+    return queue;
+  }
+}
+
+/* Driver Code */
+void main() {
+  /* Инициализация очереди */
+  final queue = LinkedListQueue();
+
+  /* Добавление элемента в очередь */
+  queue.push(1);
+  queue.push(3);
+  queue.push(2);
+  queue.push(5);
+  queue.push(4);
+  print("Очередь queue = ${queue.toArray()}");
+
+  /* Доступ к элементу в начале очереди */
+  final int peek = queue.peek();
+  print("Первый элемент peek = $peek");
+
+  /* Извлечение элемента из очереди */
+  final int pop = queue.pop();
+  print("Извлеченный элемент pop = $pop, queue после извлечения = ${queue.toArray()}");
+
+  /* Получение длины очереди */
+  final int size = queue.size();
+  print("Длина очереди size = $size");
+
+  /* Проверка, пуста ли очередь */
+  final bool isEmpty = queue.isEmpty();
+  print("Пуста ли очередь = $isEmpty");
+}

ru/codes/dart/chapter_stack_and_queue/linkedlist_stack.dart

@@ -0,0 +1,93 @@
+/**
+ * File: linkedlist_stack.dart
+ * Created Time: 2023-03-27
+ * Author: liuyuxin (gvenusleo@gmail.com)
+ */
+
+import '../utils/list_node.dart';
+
+/* Стек на основе класса связного списка */
+class LinkedListStack {
+  ListNode? _stackPeek; // Использовать головной узел как вершину стека
+  int _stkSize = 0; // Длина стека
+
+  LinkedListStack() {
+    _stackPeek = null;
+  }
+
+  /* Получение длины стека */
+  int size() {
+    return _stkSize;
+  }
+
+  /* Проверка, пуст ли стек */
+  bool isEmpty() {
+    return _stkSize == 0;
+  }
+
+  /* Поместить в стек */
+  void push(int _num) {
+    final ListNode node = ListNode(_num);
+    node.next = _stackPeek;
+    _stackPeek = node;
+    _stkSize++;
+  }
+
+  /* Извлечь из стека */
+  int pop() {
+    final int _num = peek();
+    _stackPeek = _stackPeek!.next;
+    _stkSize--;
+    return _num;
+  }
+
+  /* Доступ к верхнему элементу стека */
+  int peek() {
+    if (_stackPeek == null) {
+      throw Exception("стек пуст");
+    }
+    return _stackPeek!.val;
+  }
+
+  /* Преобразовать связный список в List и вернуть */
+  List<int> toList() {
+    ListNode? node = _stackPeek;
+    List<int> list = [];
+    while (node != null) {
+      list.add(node.val);
+      node = node.next;
+    }
+    list = list.reversed.toList();
+    return list;
+  }
+}
+
+/* Driver Code */
+void main() {
+  /* Инициализация стека */
+  final LinkedListStack stack = LinkedListStack();
+
+  /* Помещение элемента в стек */
+  stack.push(1);
+  stack.push(3);
+  stack.push(2);
+  stack.push(5);
+  stack.push(4);
+  print("Стек stack = ${stack.toList()}");
+
+  /* Доступ к верхнему элементу стека */
+  final int peek = stack.peek();
+  print("Верхний элемент peek = $peek");
+
+  /* Извлечение элемента из стека */
+  final int pop = stack.pop();
+  print("Извлеченный элемент pop = $pop, stack после извлечения = ${stack.toList()}");
+
+  /* Получение длины стека */
+  final int size = stack.size();
+  print("Длина стека size = $size");
+
+  /* Проверка на пустоту */
+  final bool isEmpty = stack.isEmpty();
+  print("Пуст ли стек = $isEmpty");
+}

ru/codes/dart/chapter_stack_and_queue/queue.dart

@@ -0,0 +1,37 @@
+/**
+ * File: queue.dart
+ * Created Time: 2023-03-28
+ * Author: liuyuxin (gvenusleo@gmail.com)
+ */
+
+import 'dart:collection';
+
+void main() {
+  /* Инициализация очереди */
+  // В Dart двусторонняя очередь Queue обычно рассматривается как обычная очередь
+  final Queue<int> queue = Queue();
+
+  /* Добавление элемента в очередь */
+  queue.add(1);
+  queue.add(3);
+  queue.add(2);
+  queue.add(5);
+  queue.add(4);
+  print("Очередь queue = $queue");
+
+  /* Доступ к элементу в начале очереди */
+  final int peek = queue.first;
+  print("Первый элемент peek = $peek");
+
+  /* Извлечение элемента из очереди */
+  final int pop = queue.removeFirst();
+  print("Извлеченный элемент pop = $pop, queue после извлечения = $queue");
+
+  /* Получить длину очереди */
+  final int size = queue.length;
+  print("Длина очереди size = $size");
+
+  /* Проверка, пуста ли очередь */
+  final bool isEmpty = queue.isEmpty;
+  print("Пуста ли очередь = $isEmpty");
+}

ru/codes/dart/chapter_stack_and_queue/stack.dart

@@ -0,0 +1,35 @@
+/**
+ * File: stack.dart
+ * Created Time: 2023-03-27
+ * Author: liuyuxin (gvenusleo@gmail.com)
+ */
+
+void main() {
+  /* Инициализация стека */
+  // В Dart нет встроенного класса стека, поэтому List можно использовать как стек
+  final List<int> stack = [];
+
+  /* Помещение элемента в стек */
+  stack.add(1);
+  stack.add(3);
+  stack.add(2);
+  stack.add(5);
+  stack.add(4);
+  print("Стек stack = $stack");
+
+  /* Доступ к верхнему элементу стека */
+  final int peek = stack.last;
+  print("Верхний элемент peek = $peek");
+
+  /* Извлечение элемента из стека */
+  final int pop = stack.removeLast();
+  print("Извлеченный элемент pop = $pop, stack после извлечения = $stack");
+
+  /* Получение длины стека */
+  final int size = stack.length;
+  print("Длина стека size = $size");
+
+  /* Проверка на пустоту */
+  final bool isEmpty = stack.isEmpty;
+  print("Пуст ли стек = $isEmpty");
+}

ru/codes/dart/chapter_tree/array_binary_tree.dart

@@ -0,0 +1,152 @@
+/**
+ * File: array_binary_tree.dart
+ * Created Time: 2023-08-15
+ * Author: liuyuxin (gvenusleo@gmail.com)
+ */
+
+import '../utils/print_util.dart';
+import '../utils/tree_node.dart';
+
+/* Класс двоичного дерева в массивном представлении */
+class ArrayBinaryTree {
+  late List<int?> _tree;
+
+  /* Конструктор */
+  ArrayBinaryTree(this._tree);
+
+  /* Вместимость списка */
+  int size() {
+    return _tree.length;
+  }
+
+  /* Получить значение узла с индексом i */
+  int? val(int i) {
+    // Если индекс выходит за границы, вернуть null, обозначающий пустую позицию
+    if (i < 0 || i >= size()) {
+      return null;
+    }
+    return _tree[i];
+  }
+
+  /* Получить индекс левого дочернего узла узла с индексом i */
+  int? left(int i) {
+    return 2 * i + 1;
+  }
+
+  /* Получить индекс правого дочернего узла узла с индексом i */
+  int? right(int i) {
+    return 2 * i + 2;
+  }
+
+  /* Получить индекс родительского узла узла с индексом i */
+  int? parent(int i) {
+    return (i - 1) ~/ 2;
+  }
+
+  /* Обход в ширину */
+  List<int> levelOrder() {
+    List<int> res = [];
+    for (int i = 0; i < size(); i++) {
+      if (val(i) != null) {
+        res.add(val(i)!);
+      }
+    }
+    return res;
+  }
+
+  /* Обход в глубину */
+  void dfs(int i, String order, List<int?> res) {
+    // Если это пустая позиция, вернуть
+    if (val(i) == null) {
+      return;
+    }
+    // Предварительный обход
+    if (order == 'pre') {
+      res.add(val(i));
+    }
+    dfs(left(i)!, order, res);
+    // Симметричный обход
+    if (order == 'in') {
+      res.add(val(i));
+    }
+    dfs(right(i)!, order, res);
+    // Обратный обход
+    if (order == 'post') {
+      res.add(val(i));
+    }
+  }
+
+  /* Предварительный обход */
+  List<int?> preOrder() {
+    List<int?> res = [];
+    dfs(0, 'pre', res);
+    return res;
+  }
+
+  /* Симметричный обход */
+  List<int?> inOrder() {
+    List<int?> res = [];
+    dfs(0, 'in', res);
+    return res;
+  }
+
+  /* Обратный обход */
+  List<int?> postOrder() {
+    List<int?> res = [];
+    dfs(0, 'post', res);
+    return res;
+  }
+}
+
+/* Driver Code */
+void main() {
+  // Инициализировать двоичное дерево
+  // Здесь используется функция, напрямую строящая двоичное дерево из массива
+  List<int?> arr = [
+    1,
+    2,
+    3,
+    4,
+    null,
+    6,
+    7,
+    8,
+    9,
+    null,
+    null,
+    12,
+    null,
+    null,
+    15
+  ];
+
+  TreeNode? root = listToTree(arr);
+  print("\nИнициализация двоичного дерева\n");
+  print("Массивное представление двоичного дерева:");
+  print(arr);
+  print("Связное представление двоичного дерева:");
+  printTree(root);
+
+  // Класс двоичного дерева в массивном представлении
+  ArrayBinaryTree abt = ArrayBinaryTree(arr);
+
+  // Доступ к узлу
+  int i = 1;
+  int? l = abt.left(i);
+  int? r = abt.right(i);
+  int? p = abt.parent(i);
+  print("\nТекущий узел: индекс = $i, значение = ${abt.val(i)}");
+  print("Индекс левого дочернего узла = $l, значение = ${(l == null ? "null" : abt.val(l))}");
+  print("Индекс правого дочернего узла = $r, значение = ${(r == null ? "null" : abt.val(r))}");
+  print("Индекс родительского узла = $p, значение = ${(p == null ? "null" : abt.val(p))}");
+
+  // Обходить дерево
+  List<int?> res = abt.levelOrder();
+  print("\nОбход в ширину = $res");
+  res = abt.preOrder();
+  print("Предварительный обход = $res");
+  res = abt.inOrder();
+  print("Симметричный обход = $res");
+  res = abt.postOrder();
+  print("Обратный обход = $res");
+}

ru/codes/dart/chapter_tree/avl_tree.dart

@@ -0,0 +1,218 @@
+/**
+ * File: avl_tree.dart
+ * Created Time: 2023-04-04
+ * Author: liuyuxin (gvenusleo@gmail.com)
+ */
+
+import 'dart:math';
+import '../utils/print_util.dart';
+import '../utils/tree_node.dart';
+
+class AVLTree {
+  TreeNode? root;
+
+  /* Конструктор */
+  AVLTree() {
+    root = null;
+  }
+
+  /* Получить высоту узла */
+  int height(TreeNode? node) {
+    // Высота пустого узла равна -1, высота листового узла равна 0
+    return node == null ? -1 : node.height;
+  }
+
+  /* Обновить высоту узла */
+  void updateHeight(TreeNode? node) {
+    // Высота узла равна высоте более высокого поддерева + 1
+    node!.height = max(height(node.left), height(node.right)) + 1;
+  }
+
+  /* Получить коэффициент баланса */
+  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 factor = balanceFactor(node);
+    // Левосторонне перекошенное дерево
+    if (factor > 1) {
+      if (balanceFactor(node!.left) >= 0) {
+        // Правое вращение
+        return rightRotate(node);
+      } else {
+        // Сначала левое вращение, затем правое
+        node.left = leftRotate(node.left);
+        return rightRotate(node);
+      }
+    }
+    // Правосторонне перекошенное дерево
+    if (factor < -1) {
+      if (balanceFactor(node!.right) <= 0) {
+        // Левое вращение
+        return leftRotate(node);
+      } else {
+        // Сначала правое вращение, затем левое
+        node.right = rightRotate(node.right);
+        return leftRotate(node);
+      }
+    }
+    // Дерево сбалансировано, вращение не требуется, вернуть сразу
+    return node;
+  }
+
+  /* Вставка узла */
+  void insert(int val) {
+    root = insertHelper(root, val);
+  }
+
+  /* Рекурсивная вставка узла (вспомогательный метод) */
+  TreeNode? insertHelper(TreeNode? node, int val) {
+    if (node == null) return 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;
+  }
+
+  /* Удаление узла */
+  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);
+        node.val = temp.val;
+      }
+    }
+    updateHeight(node); // Обновить высоту узла
+    /* 2. Выполнить вращение, чтобы снова сбалансировать поддерево */
+    node = rotate(node);
+    // Вернуть корневой узел поддерева
+    return node;
+  }
+
+  /* Поиск узла */
+  TreeNode? search(int val) {
+    TreeNode? cur = root;
+    // Искать в цикле и выйти после прохода за листовой узел
+    while (cur != null) {
+      // Целевой узел находится в правом поддереве cur
+      if (val < cur.val)
+        cur = cur.left;
+      // Целевой узел находится в левом поддереве cur
+      else if (val > cur.val)
+        cur = cur.right;
+      // Целевой узел равен текущему узлу
+      else
+        break;
+    }
+    return cur;
+  }
+}
+
+void testInsert(AVLTree tree, int val) {
+  tree.insert(val);
+  print("\nПосле вставки узла $val AVL-дерево имеет вид");
+  printTree(tree.root);
+}
+
+void testRemove(AVLTree tree, int val) {
+  tree.remove(val);
+  print("\nПосле удаления узла $val AVL-дерево имеет вид");
+  printTree(tree.root);
+}
+
+/* Driver Code */
+void main() {
+  /* Инициализация пустого AVL-дерева */
+  AVLTree avlTree = AVLTree();
+  /* Вставка узла */
+  // Обратите внимание, как 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);
+  print("\nНайденный объект узла = $node, значение узла = ${node!.val}");
+}

ru/codes/dart/chapter_tree/binary_search_tree.dart

@@ -0,0 +1,153 @@
+/**
+ * File: binary_search_tree.dart
+ * Created Time: 2023-04-04
+ * Author: liuyuxin (gvenusleo@gmail.com)
+ */
+
+import '../utils/print_util.dart';
+import '../utils/tree_node.dart';
+
+/* Двоичное дерево поиска */
+class BinarySearchTree {
+  late TreeNode? _root;
+
+  /* Конструктор */
+  BinarySearchTree() {
+    // Инициализировать пустое дерево
+    _root = null;
+  }
+
+  /* Получить корневой узел двоичного дерева */
+  TreeNode? getRoot() {
+    return _root;
+  }
+
+  /* Поиск узла */
+  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;
+  }
+
+  /* Вставка узла */
+  void insert(int _num) {
+    // Если дерево пусто, инициализировать корневой узел
+    if (_root == null) {
+      _root = TreeNode(_num);
+      return;
+    }
+    TreeNode? cur = _root;
+    TreeNode? 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 = TreeNode(_num);
+    if (pre!.val < _num)
+      pre.right = node;
+    else
+      pre.left = node;
+  }
+
+  /* Удаление узла */
+  void remove(int _num) {
+    // Если дерево пусто, сразу вернуть
+    if (_root == null) return;
+    TreeNode? cur = _root;
+    TreeNode? 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;
+      }
+    } else {
+      // Число дочерних узлов = 2
+      // Получить следующий узел после cur в симметричном обходе
+      TreeNode? tmp = cur.right;
+      while (tmp!.left != null) {
+        tmp = tmp.left;
+      }
+      // Рекурсивно удалить узел tmp
+      remove(tmp.val);
+      // Перезаписать cur значением tmp
+      cur.val = tmp.val;
+    }
+  }
+}
+
+/* Driver Code */
+void main() {
+  /* Инициализация двоичного дерева поиска */
+  BinarySearchTree bst = BinarySearchTree();
+  // Обратите внимание: разные порядки вставки порождают разные двоичные деревья; данная последовательность может построить совершенное двоичное дерево
+  List<int> nums = [8, 4, 12, 2, 6, 10, 14, 1, 3, 5, 7, 9, 11, 13, 15];
+  for (int _num in nums) {
+    bst.insert(_num);
+  }
+  print("\nИсходное двоичное дерево\n");
+  printTree(bst.getRoot());
+
+  /* Поиск узла */
+  TreeNode? node = bst.search(7);
+  print("\nНайденный объект узла = $node, значение узла = ${node?.val}");
+
+  /* Вставка узла */
+  bst.insert(16);
+  print("\nПосле вставки узла 16 двоичное дерево имеет вид\n");
+  printTree(bst.getRoot());
+
+  /* Удаление узла */
+  bst.remove(1);
+  print("\nПосле удаления узла 1 двоичное дерево имеет вид\n");
+  printTree(bst.getRoot());
+  bst.remove(2);
+  print("\nПосле удаления узла 2 двоичное дерево имеет вид\n");
+  printTree(bst.getRoot());
+  bst.remove(4);
+  print("\nПосле удаления узла 4 двоичное дерево имеет вид\n");
+  printTree(bst.getRoot());
+}

ru/codes/dart/chapter_tree/binary_tree.dart

@@ -0,0 +1,37 @@
+/**
+ * File: binary_tree.dart
+ * Created Time: 2023-04-03
+ * Author: liuyuxin (gvenusleo@gmail.com)
+ */
+
+import '../utils/print_util.dart';
+import '../utils/tree_node.dart';
+
+void main() {
+  /* Инициализация двоичного дерева */
+  // Инициализировать узлы дерева
+  TreeNode n1 = TreeNode(1);
+  TreeNode n2 = TreeNode(2);
+  TreeNode n3 = TreeNode(3);
+  TreeNode n4 = TreeNode(4);
+  TreeNode n5 = TreeNode(5);
+  // Построить связи между узлами (указатели)
+  n1.left = n2;
+  n1.right = n3;
+  n2.left = n4;
+  n2.right = n5;
+  print("\nИнициализация двоичного дерева\n");
+  printTree(n1);
+
+  /* Вставка и удаление узлов */
+  TreeNode p = TreeNode(0);
+  // Вставить узел p между n1 -> n2
+  n1.left = p;
+  p.left = n2;
+  print("\nПосле вставки узла P\n");
+  printTree(n1);
+  // Удалить узел P
+  n1.left = n2;
+  print("\nПосле удаления узла P\n");
+  printTree(n1);
+}

ru/codes/dart/chapter_tree/binary_tree_bfs.dart

@@ -0,0 +1,38 @@
+/**
+ * File: binary_tree_bfs.dart
+ * Created Time: 2023-04-03
+ * Author: liuyuxin (gvenusleo@gmai.com)
+ */
+
+import 'dart:collection';
+import '../utils/print_util.dart';
+import '../utils/tree_node.dart';
+
+/* Обход в ширину */
+List<int> levelOrder(TreeNode? root) {
+  // Инициализировать очередь и добавить корневой узел
+  Queue<TreeNode?> queue = Queue();
+  queue.add(root);
+  // Инициализировать список для хранения последовательности обхода
+  List<int> res = [];
+  while (queue.isNotEmpty) {
+    TreeNode? node = queue.removeFirst(); // Извлечение из очереди
+    res.add(node!.val); // Сохранить значение узла
+    if (node.left != null) queue.add(node.left); // Поместить левый дочерний узел в очередь
+    if (node.right != null) queue.add(node.right); // Поместить правый дочерний узел в очередь
+  }
+  return res;
+}
+
+/* Driver Code */
+void main() {
+  /* Инициализация двоичного дерева */
+  // Здесь используется функция, напрямую строящая двоичное дерево из массива
+  TreeNode? root = listToTree([1, 2, 3, 4, 5, 6, 7]);
+  print("\nИнициализация двоичного дерева\n");
+  printTree(root);
+
+  // Обход в ширину
+  List<int> res = levelOrder(root);
+  print("\nПоследовательность печати узлов при обходе в ширину = $res");
+}

ru/codes/dart/chapter_tree/binary_tree_dfs.dart

@@ -0,0 +1,62 @@
+/**
+ * File: binary_tree_dfs.dart
+ * Created Time: 2023-04-04
+ * Author: liuyuxin (gvenusleo@gmail.com)
+ */
+
+import '../utils/print_util.dart';
+import '../utils/tree_node.dart';
+
+// Инициализировать список для хранения последовательности обхода
+List<int> list = [];
+
+/* Предварительный обход */
+void preOrder(TreeNode? node) {
+  if (node == null) return;
+  // Порядок обхода: корень -> левое поддерево -> правое поддерево
+  list.add(node.val);
+  preOrder(node.left);
+  preOrder(node.right);
+}
+
+/* Симметричный обход */
+void inOrder(TreeNode? node) {
+  if (node == null) return;
+  // Порядок обхода: левое поддерево -> корень -> правое поддерево
+  inOrder(node.left);
+  list.add(node.val);
+  inOrder(node.right);
+}
+
+/* Обратный обход */
+void postOrder(TreeNode? node) {
+  if (node == null) return;
+  // Порядок обхода: левое поддерево -> правое поддерево -> корень
+  postOrder(node.left);
+  postOrder(node.right);
+  list.add(node.val);
+}
+
+/* Driver Code */
+void main() {
+  /* Инициализация двоичного дерева */
+  // Здесь используется функция, напрямую строящая двоичное дерево из массива
+  TreeNode? root = listToTree([1, 2, 3, 4, 5, 6, 7]);
+  print("\nИнициализация двоичного дерева\n");
+  printTree(root);
+
+  /* Предварительный обход */
+  list.clear();
+  preOrder(root);
+  print("\nПоследовательность печати узлов при предварительном обходе = $list");
+
+  /* Симметричный обход */
+  list.clear();
+  inOrder(root);
+  print("\nПоследовательность печати узлов при симметричном обходе = $list");
+
+  /* Обратный обход */
+  list.clear();
+  postOrder(root);
+  print("\nПоследовательность печати узлов при обратном обходе = $list");
+}

ru/codes/dart/utils/list_node.dart

@@ -0,0 +1,24 @@
+/**
+ * File: list_node.dart
+ * Created Time: 2023-01-23
+ * Author: Jefferson (JeffersonHuang77@gmail.com)
+ */
+
+/* Узел связного списка */
+class ListNode {
+  int val;
+  ListNode? next;
+
+  ListNode(this.val, [this.next]);
+}
+
+/* Десериализовать список в связный список */
+ListNode? listToLinkedList(List<int> list) {
+  ListNode dum = ListNode(0);
+  ListNode? head = dum;
+  for (int val in list) {
+    head?.next = ListNode(val);
+    head = head?.next;
+  }
+  return dum.next;
+}

ru/codes/dart/utils/print_util.dart

@@ -0,0 +1,90 @@
+/**
+ * File: print_util.dart
+ * Created Time: 2023-01-23
+ * Author: Jefferson (JeffersonHuang77@gmail.com)
+ */
+
+import 'dart:io';
+
+import 'list_node.dart';
+import 'tree_node.dart';
+
+class Trunk {
+  Trunk? prev;
+  String str;
+
+  Trunk(this.prev, this.str);
+}
+
+/* Вывести матрицу (Array) */
+void printMatrix(List<List<int>> matrix) {
+  print("[");
+  for (List<int> row in matrix) {
+    print("  $row,");
+  }
+  print("]");
+}
+
+/* Вывести связный список */
+void printLinkedList(ListNode? head) {
+  List<String> list = [];
+
+  while (head != null) {
+    list.add('${head.val}');
+    head = head.next;
+  }
+
+  print(list.join(' -> '));
+}
+
+/**
+ * Вывести двоичное дерево
+ * Этот вывод дерева заимствован из TECHIE DELIGHT
+ * https://www.techiedelight.com/c-program-print-binary-tree/
+ */
+void printTree(TreeNode? root, [Trunk? prev = null, bool isRight = false]) {
+  if (root == null) {
+    return;
+  }
+
+  String prev_str = '    ';
+  Trunk trunk = Trunk(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);
+  print(' ${root.val}');
+
+  if (prev != null) {
+    prev.str = prev_str;
+  }
+  trunk.str = '   |';
+
+  printTree(root.left, trunk, false);
+}
+
+void showTrunks(Trunk? p) {
+  if (p == null) {
+    return;
+  }
+
+  showTrunks(p.prev);
+  stdout.write(p.str);
+}
+
+/* Вывести кучу */
+void printHeap(List<int> heap) {
+  print("Массивное представление кучи: $heap");
+  print("Древовидное представление кучи:");
+  TreeNode? root = listToTree(heap);
+  printTree(root);
+}

ru/codes/dart/utils/tree_node.dart

@@ -0,0 +1,50 @@
+/**
+ * File: tree_node.dart
+ * Created Time: 2023-2-12
+ * Author: Jefferson (JeffersonHuang77@gmail.com)
+ */
+
+/* Класс узла двоичного дерева */
+class TreeNode {
+  int val; // Значение узла
+  int height; // Высота узла
+  TreeNode? left; // Ссылка на левый дочерний узел
+  TreeNode? right; // Ссылка на правый дочерний узел
+
+  /* Конструктор */
+  TreeNode(this.val, [this.height = 0, this.left, this.right]);
+}
+
+/* Десериализовать список в двоичное дерево: рекурсия */
+TreeNode? listToTreeDFS(List<int?> arr, int i) {
+  if (i < 0 || i >= arr.length || arr[i] == null) {
+    return null;
+  }
+  TreeNode? root = TreeNode(arr[i]!);
+  root.left = listToTreeDFS(arr, 2 * i + 1);
+  root.right = listToTreeDFS(arr, 2 * i + 2);
+  return root;
+}
+
+/* Десериализовать список в двоичное дерево */
+TreeNode? listToTree(List<int?> arr) {
+  return listToTreeDFS(arr, 0);
+}
+
+/* Сериализовать двоичное дерево в список: рекурсия */
+void treeToListDFS(TreeNode? root, int i, List<int?> res) {
+  if (root == null) return;
+  while (i >= res.length) {
+    res.add(null);
+  }
+  res[i] = root.val;
+  treeToListDFS(root.left, 2 * i + 1, res);
+  treeToListDFS(root.right, 2 * i + 2, res);
+}
+
+/* Сериализовать двоичное дерево в список */
+List<int?> treeToList(TreeNode? root) {
+  List<int?> res = [];
+  treeToListDFS(root, 0, res);
+  return res;
+}

ru/codes/dart/utils/vertex.dart

@@ -0,0 +1,29 @@
+/**
+ * File: Vertex.dart
+ * Created Time: 2023-05-15
+ * Author: liuyuxin (gvenusleo@gmail.com)
+ */
+
+/* Класс вершины */
+class Vertex {
+  int val;
+  Vertex(this.val);
+
+  /* На вход подается список значений vals, на выходе возвращается список вершин vets */
+  static List<Vertex> valsToVets(List<int> vals) {
+    List<Vertex> vets = [];
+    for (int i in vals) {
+      vets.add(Vertex(i));
+    }
+    return vets;
+  }
+
+  /* На вход подается список вершин vets, на выходе возвращается список значений vals */
+  static List<int> vetsToVals(List<Vertex> vets) {
+    List<int> vals = [];
+    for (Vertex vet in vets) {
+      vals.add(vet.val);
+    }
+    return vals;
+  }
+}