Разделяй и властвуй

Author: Anton Gorinenko

README.md

@@ -47,6 +47,8 @@
 
 [Рекурсия](tutorial/recursion.md)
 
+[Разделяй и властвуй](tutorial/divide_and_conquer.md)
+
 [Динамическое программирование](tutorial/dynamic_programming.md) (в работе)
 
 [Жадные алгоритмы](tutorial/greedy.md) (в работе)

img/merge_sort.png

@@ -0,0 +1,20 @@
+# Разделяй и властвуй
+
+**"Разделяй и властвуй"** — схема разработки алгоритмов, заключающаяся в рекурсивном разбиении решаемой задачи на две
+или более подзадачи того же типа, но меньшего размера, и комбинировании их решений для получения ответа к исходной
+задаче; разбиения выполняются до тех пор, пока все подзадачи не окажутся элементарными. Рекурсия естественным образом
+подходит для решения задач данного класса. Основная идея схемы состоит в том, чтобы разбить задачу на две или более
+сходных, но более простых подзадач, решить их поочерёдно и объединить их решения. Это отличает "разделяй и властвуй" от
+других рекурсивных алгоритмов, которые последовательно решают более простые задачи, сводящиеся к базовому случаю.
+Примером последних может служить бинарный поиск, класс таких задач называют **"уменьшай и властвуй"**.
+
+Алгоритм "разделяй и властвуй" состоит из трех шагов:
+
+1. Разбиение изначальной проблемы на несколько более простых задач
+1. Решение каждой под задачи рекурсивным способом
+1. Объединение решений подзадач в одно общее решение
+
+Ниже приведено наглядное представление алгоритма сортировки слиянием, которая реализует принципы "разделяй и властвуй".
+
+![Сортировка слиянием](../img/merge_sort.png)
+   

img/merge_sort_1.png

@@ -1 +1,108 @@
-# Сортировка слиянием
+# Сортировка слиянием
+
+Одним классическим примером алгоритма "разделяй и властвуй" является сортировка слиянием.
+
+Существует два подхода реализации сортировки слиянием "сверху вниз" и "снизу вверх". Первый вариант можно просто
+реализовать с использованием рекурсии. Задача сортировки слиянием ставится и решается следующим образом:
+
+1) Дан неотсортированный список, например список чисел. Требуется отсортировать список в порядке возрастания или
+   убывания.
+2) На первом шаге разделим данный список на два
+3) На следующем шаге рекурсивно отсортируем два списка, полученные на первом шаге. В процессе рекурсии сортируемые
+   списки будут становиться все меньше, пока не станут пустыми или не будут состоять из одного элемента. Это будет базой
+   рекурсии.
+4) Наконец мы объединяем отсортированные списки, полученные на предыдущем шаге.
+
+Алгоритм сортировки слиянием представлен ниже.
+
+![Сортировка слиянием](../img/merge_sort.png)
+
+Итак, после разбиения двух списков необходимо провести слияние. Сложность этого шага будет O(n), где n - общее
+количество элементов в двух списках. Слияние реализуется с использованием двух указателей и дополнительного списка
+
+![Слияние](../img/merge_sort_1.png)
+
+Реализация сортировки слиянием на python:
+
+```python
+def merge_sort(nums):
+    """
+    Сортировка
+    """
+    # Базовый случай
+    if len(nums) <= 1:
+        return nums
+    # Разделяем
+    pivot = int(len(nums) / 2)
+    # Рекурсивно решаем более простую задачу
+    left_list = merge_sort(nums[0:pivot])
+    right_list = merge_sort(nums[pivot:])
+    # Объединяем
+    return merge(left_list, right_list)
+
+
+def merge(left_list, right_list):
+    """
+    Слияние
+    """
+    left_cursor = right_cursor = 0
+    ret = []
+    while left_cursor < len(left_list) and right_cursor < len(right_list):
+        if left_list[left_cursor] < right_list[right_cursor]:
+            ret.append(left_list[left_cursor])
+            left_cursor += 1
+        else:
+            ret.append(right_list[right_cursor])
+            right_cursor += 1
+
+    ret.extend(left_list[left_cursor:])
+    ret.extend(right_list[right_cursor:])
+
+    return ret
+```
+
+В подходе "снизу вверх", мы делим список на подсписки по 1 элементу и затем рекурсивно объединяем их уже известным нам
+способом.
+
+![Сортировка слиянием снизу вверх](../img/merge_sort_2.png)
+
+Реализация сортировки слиянием методом снизу вверх выглядит следующим образом:
+
+```python
+from collections import deque
+
+
+def merge_sort(nums):
+    """
+    Sort
+    """
+    # Divide and conquer
+    res = deque([[i] for i in nums])
+    # Merge
+    while len(res) > 1:
+        one = res.popleft()
+        two = res.popleft()
+        res.append(merge(one, two))
+
+    return res[0]
+
+
+def merge(left_list, right_list):
+    """
+    Merge
+    """
+    left_cursor = right_cursor = 0
+    ret = []
+    while left_cursor < len(left_list) and right_cursor < len(right_list):
+        if left_list[left_cursor] < right_list[right_cursor]:
+            ret.append(left_list[left_cursor])
+            left_cursor += 1
+        else:
+            ret.append(right_list[right_cursor])
+            right_cursor += 1
+
+    ret.extend(left_list[left_cursor:])
+    ret.extend(right_list[right_cursor:])
+
+    return ret
+```

img/merge_sort_2.png

@@ -13,8 +13,8 @@
 **сбалансированными**. Такие рандомизированные деревья поиска обеспечивают сбалансированность только в вероятностном
 смысле. Они обладают следующими свойствами:
 
-1) имеют небольшую высоту
-1) имеют хорошую заполненность уровней
+1. имеют небольшую высоту  
+1. имеют хорошую заполненность уровней
 
 На рисунке ниже слева приведен пример сбалансированного дерева, которое получается для
 ключей ``[ 9, 2, 13, 7, 1, 11, 14]``. Справа изображено **несбалансированное дерево** для упорядоченных

tutorial/divide_and_conquer.md

@@ -64,6 +64,10 @@ def remove_element(arr: List[int], val: int):
    исключение.
 2. Следует правильно выбрать условие окончания прохода по списку.
 
+Рассмотрим задачу, где учитываются эти особенности.
+
+Оригинал: [141. Linked List Cycle](https://leetcode.com/problems/linked-list-cycle/description/)
+
 ```python
 def test_has_cycle():
     list_1 = create_list_from_array([3, 2, 0, -4], 1)