feat: move unfinished topics to another branch

Author: everysoftware

README.md

@@ -1,13 +1,13 @@
-# Алгоритмы
+# Algorithms Course
 
-Курс по алгоритмам и структурам данных с разбором теории и решением задач.
+Авторский курс по алгоритмам и структурам данных с разбором теории и решением задач.
 
-## Основные фичи
+## Ключевые особенности
 
-- **10+** разобранных тем, к каждой теме легкий конспект
+- **13** разобранных тем, к каждой теме легкий конспект
 - **70+** практических задач с LeetCode, тренировок от Яндекса и реальных собеседований
 - Решение **к каждой задаче** на лаконичном Python с комментариями
-- **750+** автоматизированных тестов для проверки решений
+- **800+** автоматизированных тестов для проверки решений
 
 ## Структура курса
 
@@ -26,9 +26,14 @@
 | 11 | Теория чисел                     | Продвинутые подходы          | `k_number_theory` |
 | 12 | 2D Динамическое программирование | Продвинутые подходы          | `l_dp2`           |
 | 13 | Деревья                          | Продвинутые структуры данных | `m_trees`         |
-| 14 | Графы                            | Продвинутые структуры данных | `n_graphs`        |
 
-Каждая тема содержит теорию, практические задачи и их решения.
+Каждая тема содержит:
+
+* **Теоретический конспект**, легко и доступно объясняющий тему (файл `ABSTRACT.md`)
+* **Подборка задач** разного уровня сложности на отработку полученных навыков (файл `README.md`)
+* **Решения задач** из подборки на Python (файлы `*.py`, например `fib.py`)
+* **Автотесты** для каждого решения, покрывающие минимальный набор ошибок (папка `/tests/`, например
+  `/tests/test_intro/test_fib.py`)
 
 ## Источники
 

snippets/__init__.py

@@ -165,3 +165,91 @@ A -> B -> D -> E -> C -> F
 * **Прямой обход** (Pre-order): сначала посещается корень, затем левое поддерево, затем правое поддерево.
 * **Симметричный обход** (In-order): сначала посещается левое поддерево, затем корень, затем правое поддерево.
 * **Обратный обход** (Post-order): сначала посещается левое поддерево, затем правое поддерево, затем корень.
+
+## Обход в ширину
+
+**BFS** (Breadth-First Search) - обход в ширину - это алгоритм обхода графа или дерева, который начинается с
+начальной вершины и проходит по всем вершинам на текущем уровне, прежде чем перейти к следующему уровню.
+Сложность BFS: O(N), N = V + E, где V - количество вершин, E - количество ребер.
+
+Пример.
+Возьмем дерево:
+
+```text
+    A
+   / \
+  B   C
+ / \   \
+D   E   F
+```
+
+Обход в ширину начинается с вершины A и проходит по всем вершинам на текущем уровне:
+
+```text
+A -> B -> C -> D -> E -> F
+```
+
+По-другому обход в ширину можно представить в виде уровней:
+
+```text
+Уровень 0: A
+Уровень 1: B, C
+Уровень 2: D, E, F
+```
+
+Поэтому обход в ширину также называют **уровневым обходом** (Level-order).
+
+## Деревья поиска
+
+**Дерево поиска** - это двоичное дерево, в котором для каждой вершины выполняется следующее условие:
+
+* Все ключи в левом поддереве меньше ключа вершины.
+* Все ключи в правом поддереве больше ключа вершины.
+* Левое и правое поддеревья также являются деревьями поиска.
+
+Деревья поиска позволяют эффективно выполнять операции поиска, вставки и удаления элементов.
+
+Сложность операций в дереве поиска: O(log N) в среднем случае, O(N) в худшем случае (если дерево вырождено в список).
+
+Пример.
+
+```text
+    4
+   / \
+  2   6
+ / \   \
+1   3   5
+```
+
+## Сбалансированные деревья
+
+**Сбалансированное дерево** - это дерево, в котором высота левого и правого поддеревьев для каждой вершины отличается не
+более чем на 1.
+
+Сбалансированные деревья позволяют поддерживать операции поиска, вставки и удаления элементов с логарифмической
+сложностью O(log N) в худшем случае.
+
+Пример сбалансированного дерева:
+
+```text
+    4
+   / \
+  2   6
+ / \   \
+1   3   5
+```
+
+Это дерево сбалансировано, потому что высота левого и правого поддеревьев для каждой вершины отличается
+не более чем на 1.
+
+Существует несколько типов сбалансированных деревьев:
+
+* **AVL-деревья** - это сбалансированные двоичные деревья поиска, в которых для каждой вершины высота левого и правого
+  поддеревьев отличается не более чем на 1.
+* **Красно-черные деревья** - это сбалансированные двоичные деревья поиска, в которых каждая вершина имеет цвет (красный
+  или черный) и выполняются определенные правила для поддержания баланса.
+* **Splay-деревья** - это сбалансированные двоичные деревья поиска, которые автоматически перемещают часто
+  используемые элементы ближе к корню дерева, что позволяет ускорить доступ к ним.
+* **B-деревья** - это сбалансированные деревья поиска, которые используются в базах данных и файловых системах для
+  эффективного хранения и поиска больших объемов данных. Они позволяют хранить множество ключей в одной вершине и
+  обеспечивают логарифмическую сложность операций поиска, вставки и удаления.

snippets/huffman_heap.py

@@ -45,7 +45,7 @@ def dfs_preorder_iterative(node: BNode) -> list[int]:
     while st:
         node = st.pop()
         result.append(node.key)
-        # Push right first so that left is processed first
+        # Кладем в стек правого потомка перед левого, чтобы левый обрабатывался первым
         if node.right is not None:
             st.append(node.right)
         if node.left is not None:
@@ -63,12 +63,12 @@ def dfs_postorder_iterative(node: BNode) -> list[int]:
     while st:
         node = st.pop()
         result.append(node.key)
-        # Push left first so that right is processed first
+        # Кладем в стек левого потомка перед правого, чтобы правый обрабатывался первым
         if node.left is not None:
             st.append(node.left)
         if node.right is not None:
             st.append(node.right)
-    # Reverse the result to get postorder
+    # Поскольку мы добавляли узлы в обратном порядке, нужно развернуть результат
     result.reverse()
     return result
 
@@ -82,13 +82,12 @@ def dfs_inorder_iterative(node: BNode) -> list[int]:
     result: list[int] = []
     curr: BNode | None = node
     while st or curr is not None:
-        # Go to the leftmost node
+        # Переходим к самому левому узлу
         if curr is not None:
             st.append(curr)
             curr = curr.left
-        # Process the node
         else:
-            # Pop from stack and visit the node
+            # Когда достигли самого левого узла, обрабатываем егои переходим к правому
             curr = st.pop()
             result.append(curr.key)
             curr = curr.right

src/m_trees/ABSTRACT.md

@@ -1,3 +1,6 @@
+from collections import deque
+
+
 # O(n^2)
 def tree_height_naive(parents: list[int], node: int = -1) -> int:
     n = len(parents)
@@ -46,3 +49,26 @@ def dfs_iterative(node: int, tree: list[list[int]]) -> int:
             # Обновляем высоту дерева для текущего узла
             dp[child] = max(dp[child], dp[curr] + 1)
     return max(dp)
+
+
+# O(n)
+def tree_height_bfs(parents: list[int]) -> int:
+    root, adjacency_list = build_tree(parents)
+    return bfs(root, adjacency_list)
+
+
+# O(n)
+def bfs(node: int, tree: list[list[int]]) -> int:
+    n = len(tree)
+    dp = [1] * n
+    queue = deque([node])
+    visited = [False] * n
+    while queue:
+        curr = queue.popleft()
+        if visited[curr]:
+            continue
+        visited[curr] = True
+        for child in tree[curr]:
+            queue.append(child)
+            dp[child] = max(dp[child], dp[curr] + 1)
+    return max(dp)