readme done

Author: erik770

README.md

@@ -1,24 +1,25 @@
 # [Technopark](https://park.vk.company/) algorithms
 Реализация различных алгоритмов на С / С++ для первого семестра Технопарка.
 
-* [Алгоритм Дейкстры для разреженных графов.](
-  https://github.com/OlegSchwann/Technopark-algorithms/blob/master/3-й%20модуль/3%20задание/main.cpp)
-* [Вычисление всех возможных кратчайших путей в неорентированном графе.](
-  https://github.com/OlegSchwann/Technopark-algorithms/blob/master/3-й%20модуль/2%20задание/main.cpp)
-* [4 разных реализации хранения графов.](
-  https://github.com/OlegSchwann/Technopark-algorithms/tree/master/3-й%20модуль/1%20задание)
-* [Самобалансирующееся АВЛ-дерево.](
-  https://github.com/OlegSchwann/Technopark-algorithms/blob/master/2-й%20модуль/4%20задание%201%20вариант/main.cpp)
-* [Декартово дерево.](
-  https://github.com/OlegSchwann/Technopark-algorithms/blob/master/2-й%20модуль/3%20задание%201%20вариант/main.cpp)
+# Модуль 3
+* [Алгоритм Дейкстры для разреженных графов(задача поиска кратчайшего расстояния между городами).](modules3/cities/main.cpp)
+* [Вычисление всех возможных кратчайших путей в неорентированном графе.](module3/NumbOfShortestPaths/main.cpp)
+* [4 разных реализации хранения графов(условие задания):](modeule3/Graphs/README(условие).md)
+    - [ListGraph](ListGraph/src/ListGraph.cpp), хранящий граф в виде массива списков смежности,
+    - [MatrixGraph](MatrixGraph/src/MatrixGraph.cpp), хранящий граф в виде матрицы смежности,
+    - [SetGraph](SetGraph/src/SetGraph.cpp), хранящий граф в виде массива хэш-таблиц/сбалансированных деревьев поиска,
+    - [ArcGraph](ArcGraph/src/ArcGraph.cpp), хранящий граф в виде одного массива пар {from, to}.
+### Модуль 2
+* [Самобалансирующееся АВЛ-дерево. Реализация + решение задачи про распределению солдат по росту](module2/AVL_tree_using(soilders)/main.cpp)
+* [Декартово дерево.](module2/сartesian_tree/main.cpp)
 * [Обход бинарного дерева поиска в порядке in-order без рекурсии.](module2/binary-tree/main.cpp)
 * [Хеш-таблица с открытой адресацией и разрешением коллизий методом квадратичного пробирования. Вычисление хеша методом Горнера.](module2/hash_table/main.cpp)
 ### Модуль 1
-* [Реализация сортировки слиянием. Решение задачи на кол-во показов рекламы клиенту.](module1/7/adv_cpint_merge_sort.cpp)
+* [Реализация сортировки слиянием. Решение задачи на кол-во показов рекламы клиенту.](module1/7/adv_count_merge_sort.cpp)
 * [Алгоритм поиска k-й порядковой статистики (числа которое бы стояло на позиции с индексом k в отсортированном массиве). Поиск медианы и перцентили.](module1/6/main.cpp)
 * [Слиянеие K отсортированных массивов при помощи кучи.(Heap merge)](module1/4/heap_merge.cpp)
 * [Реализация очереди на двух стеках.](module1/3.3/queue.cpp)
 * [Реализация дека на зацикленном динамическом буффере.](module1/3/deq2.cpp)
 * [Нахождение пересечения двух массивов неповторяющихся целых чисел, упорядоченных по возрастанию.](module1/2.3/binary3.cpp)
 * [Бинарный и экспоненциальный поиск. Найти границу после которой массив строго убывает за log(m).](module1/2/binary.cpp)
-* [Работа с битовм сдвигом. Проверка по маске](module1/1/bit.cpp)
+* [Работа с битовым сдвигом. Проверка по маске](module1/1/bit.cpp)

module2/AVL_tree_using(soilders)/main.cpp

@@ -16,6 +16,54 @@
 //На каждую команду 1 (добавление в строй) вы должны выводить число K – номер позиции, на которую должен встать этот
 //солдат (все стоящие за ним двигаются назад).
 
+/*
+Пример 1
+Ввод
+5
+1 100
+1 200
+1 50
+2 1
+1 150
+Вывод
+0
+0
+2
+1
+Пример 2
+Ввод
+
+15
+1 41
+1 18467
+2 0
+1 26500
+1 19169
+2 1
+1 11478
+1 29358
+2 2
+1 24464
+1 5705
+2 0
+1 23281
+1 16827
+2 1
+Вывод
+0
+0
+0
+1
+1
+0
+2
+3
+2
+3
+*/
+
+
+
 #include <iostream>
 
 template<class T>
@@ -95,6 +143,20 @@ class AVLTree {
 
     }
 
+    /* Вставка ключей
+    Вставка нового ключа в АВЛ-дерево выполняется, так же, как это делается в простых деревьях поиска:
+    спускаемся вниз по дереву, выбирая правое или левое направление движения
+    в зависимости от результата сравнения ключа в текущем узле и вставляемого ключа.
+    Единственное отличие заключается в том, что при возвращении из рекурсии
+    (после того, как ключ вставлен либо в правое, либо в левое поддерево, и это дерево сбалансировано)
+    выполняется балансировка текущего узла. Строго доказывается, что возникающий при такой вставке дисбаланс
+    в любом узле по пути движения не превышает двух,
+    а значит применение вышеописанной функции балансировки является корректным.
+    Важно, что балансировка дерева не нарушает позицию в массиве (порядковую статистику каждого элемента)
+    Можно считать новый индекс и до того, как мы окончательно добавили новый узел.
+    если идём налево при выборе ничего не прибавляем
+    если идём направо - прибавляем количество элементов слева + 1
+    */
     Node *insertInternal(const Key &key, Node *node, size_t &position) {
         if (!node) {
             return new Node(key);
@@ -108,7 +170,18 @@ class AVLTree {
         }
         return balance(node);
     }
-
+    
+    /* Удаление ключей
+    С удалением узлов из АВЛ-дерева, все не так просто, как с рандомизированными деревьями поиска.
+    Идея следующая: находим узел x с заданным ключом k (если не находим, то делать ничего не надо),
+    в правом поддереве находим узел min с наименьшим ключом и заменяем удаляемый узел p на найденный узел min.
+    Если у найденного узела x нет правого поддерева, то по свойству АВЛ-дерева слева у этого узла может
+    быть только один единственный дочерний узел (дерево высоты 1), либо узел p вообще лист.
+    В обоих этих случаях надо просто удалить узел p и вернуть в качестве результата
+    указатель на левый дочерний узел узла x.
+    Пусть теперь правое поддерево у x есть. Находим минимальный ключ в этом поддереве.
+    По свойству двоичного дерева поиска этот ключ находится в конце левой ветки, начиная от корня дерева.
+    Применяем рекурсивную функцию: */
     Node *eraseInternal(size_t position, Node *node) {
         if (!node || position > get_num_of_el(node)) {
             return nullptr;
@@ -137,7 +210,12 @@ class AVLTree {
         }
         return balance(node);
     }
-
+    /*Очевидно, что операции вставки и удаления (а также более простая операция поиска)
+    выполняются за время пропорциональное высоте дерева, т.к. в процессе выполнения этих операций производится
+    спуск из корня к заданному узлу, и на каждом уровне выполняется некоторое фиксированное число действий. А в
+    силу того, что АВЛ-дерево является сбалансированным, его высота зависит логарифмически от числа узлов. Таким
+    образом, время выполнения всех трех базовых операций гарантированно логарифмически зависит от числа узлов дерева.*/
+    
     void destrInternal(Node* node){
         if(node){
             destrInternal(node->left);
@@ -162,6 +240,44 @@ class AVLTree {
         return balance(node);
     }
 
+    /*
+    Балансировка узлов
+    В процессе добавления или удаления узлов в АВЛ-дереве возможно возникновение ситуации,
+    когда balance factor некоторых узлов оказывается равными 2 или -2, возникает расбалансировка поддерева.
+    Для выправления ситуации применяются повороты вокруг тех или иных узлов дерева.
+    Простой поворот вправо (влево) производит следующую трансформацию дерева:
+                 y  <--левый-правый-->  x
+                / \                    / \
+               /   \                  /   \
+              x     c                a     y
+             / \   /=\              /=\   / \
+            /   \                        /   \
+           a     b                      b     c
+          /=\   /=\                    /=\   /=\
+                    A < x < B < y < c
+    Код, реализующий правый поворот, выглядит следующим образом (как обычно, каждая функция, изменяющая дерево,
+    возвращает новый корень полученного дерева): */
+    
+     Node *rotate_right(Node *node) {
+        Node *tmp = node->left;
+        node->left = tmp->right;
+        tmp->right = node;
+        fix_height_and_num_of_el(node);
+        fix_height_and_num_of_el(tmp);
+        return tmp;
+    }
+    
+    /* Левый поворот является симметричной копией правого: */
+    Node *rotate_left(Node *node) {
+        Node *tmp = node->right;
+        node->right = tmp->left;
+        tmp->left = node;
+        fix_height_and_num_of_el(node);
+        fix_height_and_num_of_el(tmp);
+        return tmp;
+    }
+
+    // Код, выполняющий балансировку, сводится к проверке условий и выполнению поворотов:
     Node *balance(Node *node) {
         fix_height_and_num_of_el(node);
 
@@ -182,25 +298,10 @@ class AVLTree {
                 return node;
         }
     }
+    /* Описанные функции поворотов и балансировки также не содержат ни циклов, ни рекурсии,
+    а значит выполняются за постоянное время, не зависящее от размера АВЛ-дерева. */
 
-    Node *rotate_left(Node *node) {
-        Node *tmp = node->right;
-        node->right = tmp->left;
-        tmp->left = node;
-        fix_height_and_num_of_el(node);
-        fix_height_and_num_of_el(tmp);
-        return tmp;
-    }
-
-    Node *rotate_right(Node *node) {
-        Node *tmp = node->left;
-        node->left = tmp->right;
-        tmp->right = node;
-        fix_height_and_num_of_el(node);
-        fix_height_and_num_of_el(tmp);
-        return tmp;
-    }
-
+    
     int8_t get_height(Node *node) {
         if (node) {
             return node->height;

module2/сartesian_tree/CMakeLists.txt

@@ -0,0 +1,6 @@
+cmake_minimum_required(VERSION 3.21)
+project(сartesian_tree)
+
+set(CMAKE_CXX_STANDARD 14)
+
+add_executable(сartesian_tree main.cpp)