fix(guide): simplify directory structure

guide/russian/algorithms/sorting-algorithms/bubble-sort/index.md

@@ -0,0 +1,154 @@
+---
+title: Bubble Sort
+localeTitle: Сортировка пузырьков
+---
+## Сортировка пузырьков
+
+Bubble Sort - это самый простой алгоритм сортировки, который работает путем многократной замены соседних элементов, если они находятся в неправильном порядке.
+
+Это очень медленный алгоритм сортировки по сравнению с такими алгоритмами, как quicksort, с наихудшей сложностью O (n ^ 2). Однако компромисс заключается в том, что сортировка пузырьков - один из самых простых алгоритмов сортировки для реализации с нуля.
+
+### Пример:
+
+#### Первый проход:
+
+(5 1 4 2 8) -> (1 5 4 2 8). Здесь алгоритм сравнивает первые два элемента и свопы с 5> 1.
+
+(1 5 4 2 8) -> (1 4 5 2 8), своп с 5> 4
+
+(1 4 5 2 8) -> (1 4 2 5 8), своп с 5> 2
+
+(1 4 2 5 8) -> (1 4 2 5 8). Теперь, поскольку эти элементы уже в порядке (8> 5), алгоритм их не заменяет.
+
+#### Второй проход:
+
+(1 4 2 5 8) -> (1 4 2 5 8)
+
+(1 4 2 5 8) -> (1 2 4 5 8), своп с 4> 2
+
+(1 2 4 5 8) -> (1 2 4 5 8)
+
+(1 2 4 5 8) -> (1 2 4 5 8)
+
+Теперь массив уже отсортирован, но наш алгоритм не знает, завершен ли он. Алгоритму нужен один полный проход без обмена, чтобы знать, что он отсортирован.
+
+#### Третий проход:
+
+(1 2 4 5 8) -> (1 2 4 5 8)
+
+(1 2 4 5 8) -> (1 2 4 5 8)
+
+(1 2 4 5 8) -> (1 2 4 5 8)
+
+(1 2 4 5 8) -> (1 2 4 5 8)
+
+#### свойства
+
+*   Сложность пространства: O (1)
+*   Лучшая производительность: O (n)
+*   Средняя производительность: O (n \* n)
+*   Наихудшая производительность: O (n \* n)
+*   Стабильный: Да
+
+### Объяснение видео
+
+[Пузырь сортировать легко](https://www.youtube.com/watch?v=Jdtq5uKz-w4)
+
+Этот код будет использовать сортировку пузырьков для сортировки массива.
+
+```js
+let arr = [1, 4, 7, 45, 7,43, 44, 25, 6, 4, 6, 9]; 
+ let sorted = false 
+ 
+ while(!sorted) { 
+  sorted = true 
+  for(var i=0; i < arr.length; i++) { 
+    if(arr[i] < arr[i-1]) { 
+      let temp = arr[i]; 
+      arr[i] = arr[i-1]; 
+      arr[i-1] = temp; 
+      sorted = false; 
+    } 
+  } 
+ } 
+```
+
+### Свойства:
+
+*   Космическая сложность: O (1)
+*   Сложность времени: O (n), O (n \* n), O (n \* n) для наилучших, средних и худших случаев соответственно.
+*   На месте: Да
+*   Стабильный: Да
+
+\======= Вот алгоритм, написанный на Java.
+
+```java
+public class bubble-sort { 
+    static void sort(int[] arr) { 
+        int n = arr.length; 
+        int temp = 0; 
+         for(int i=0; i < n; i++){ 
+                 for(int x=1; x < (ni); x++){ 
+                          if(arr[x-1] > arr[x]){ 
+                                 temp = arr[x-1]; 
+                                 arr[x-1] = arr[x]; 
+                                 arr[x] = temp; 
+                         } 
+ 
+                 } 
+         } 
+ 
+    } 
+    public static void main(String[] args) { 
+ 
+        for(int i=0; i < 15; i++){ 
+            int arr[i] = (int)(Math.random() * 100 + 1); 
+        } 
+ 
+                System.out.println("array before sorting\n"); 
+                for(int i=0; i < arr.length; i++){ 
+                        System.out.print(arr[i] + " "); 
+                } 
+                bubbleSort(arr); 
+                System.out.println("\n array after sorting\n"); 
+                for(int i=0; i < arr.length; i++){ 
+                        System.out.print(arr[i] + " "); 
+                } 
+ 
+        } 
+ } 
+```
+
+\=======
+
+### Рекурсивная реализация Bubble Sort.
+
+```c++
+void bubblesort(int arr[], int n) 
+ { 
+    if(n==1)    //Initial Case 
+        return; 
+ 
+    for(int i=0;i<n-1;i++)  //After this pass the largest element will move to its desired location. 
+    { 
+        if(arr[i]>arr[i+1]) 
+        { 
+            temp=arr[i]; 
+            arr[i]=arr[i+1]; 
+            arr[i+1]=temp; 
+        } 
+    } 
+ 
+    bubblesort(arr,n-1);    //Recursion for remaining array 
+ } 
+```
+
+### Больше информации
+
+*   [Википедия](https://en.wikipedia.org/wiki/Bubble_sort)
+*   [Алгоритм сортировки пузырьков - CS50](https://youtu.be/Ui97-_n5xjo)
+*   [Алгоритм сортировки пузырьков - GeeksForGeeks (статья)](http://www.geeksforgeeks.org/bubble-sort)
+*   [Алгоритм сортировки пузырьков - MyCodeSchool (видео)](https://www.youtube.com/watch?v=Jdtq5uKz-w4)
+*   [Алгоритмы: Bubble Sort - HackerRank (видео)](https://www.youtube.com/watch?v=6Gv8vg0kcHc)
+*   [Алгоритм сортировки пузырьков - GeeksForGeeks (видео)](https://www.youtube.com/watch?v=nmhjrI-aW5o)
+*   [Визуализация сортировки пузырьков](https://www.hackerearth.com/practice/algorithms/sorting/bubble-sort/visualize/)

guide/russian/algorithms/sorting-algorithms/bucket-sort/index.md

@@ -0,0 +1,46 @@
+---
+title: Bucket Sort
+localeTitle: Сортировать по
+---
+## Что такое сортировка ковша?
+
+Сортировка ведра - это алгоритм сортировки сортировки, который работает с элементами, деля их на разные ведра, а затем сортируя эти ведра индивидуально. Каждое ведро сортируется индивидуально с использованием отдельного алгоритма сортировки или путем рекурсивного применения алгоритма сортировки ведра. Сортировка ковша в основном полезна, когда вход равномерно распределен по диапазону.
+
+## Предположим, перед ними стоит следующая проблема:
+
+Каждому был задан большой массив чисел с плавающей запятой, равномерно расположенных между нижней и верхней границей. Этот массив теперь должен быть отсортирован. Простым способом решения этой проблемы будет использование другого алгоритма сортировки, такого как сортировка слияния, сортировка кучи или быстрая сортировка. Однако, эти алгоритмы гарантируют наилучшую временную сложность O (NlogN). Однако, используя сортировку ведра, вышеуказанная задача может быть завершена в O (N) времени.
+
+Давайте поближе рассмотрим это.
+
+Подумайте, нужно создать массив списков, т. Е. Ведер. Теперь элементы должны быть вставлены в эти ведра на основе их свойств. Затем каждый из этих ведер можно сортировать индивидуально, используя Sorting Sort.
+
+### Псевдокод для сортировки ковша:
+```
+void bucketSort(float[] a,int n) 
+ 
+ { 
+ 
+    for(each floating integer 'x' in n) 
+ 
+    { 
+ 
+        insert x into bucket[n*x]; 
+ 
+    } 
+ 
+    for(each bucket) 
+ 
+    { 
+ 
+        sort(bucket); 
+ 
+    } 
+ 
+ } 
+```
+
+### Дополнительная информация:
+
+*   [Википедия](https://en.wikipedia.org/wiki/Bucket_sort)
+    
+*   [GeeksForGeeks](http://www.geeksforgeeks.org/bucket-sort-2/)

guide/russian/algorithms/sorting-algorithms/counting-sort/index.md

@@ -0,0 +1,56 @@
+---
+title: Counting Sort
+localeTitle: Подсчет сортировки
+---
+## Подсчет сортировки
+
+Counting Sort - метод сортировки, основанный на ключах между определенным диапазоном. Он работает, подсчитывая количество объектов, имеющих разные ключевые значения (вид хэширования). Затем выполните некоторую арифметику, чтобы вычислить положение каждого объекта в выходной последовательности.
+
+### Пример:
+```
+For simplicity, consider the data in the range 0 to 9. 
+ Input data: 1, 4, 1, 2, 7, 5, 2 
+  1) Take a count array to store the count of each unique object. 
+  Index:     0  1  2  3  4  5  6  7  8  9 
+  Count:     0  2  2  0  1  1  0  1  0  0 
+ 
+  2) Modify the count array such that each element at each index 
+  stores the sum of previous counts. 
+  Index:     0  1  2  3  4  5  6  7  8  9 
+  Count:     0  2  4  4  5  6  6  7  7  7 
+ 
+ The modified count array indicates the position of each object in 
+ the output sequence. 
+ 
+  3) Output each object from the input sequence followed by 
+  decreasing its count by 1. 
+  Process the input data: 1, 4, 1, 2, 7, 5, 2. Position of 1 is 2. 
+  Put data 1 at index 2 in output. Decrease count by 1 to place 
+  next data 1 at an index 1 smaller than this index. 
+```
+
+### Реализация
+
+```js
+let numbers = [1, 4, 1, 2, 7, 5, 2]; 
+ let count = []; 
+ let i, z = 0; 
+ let max = Math.max(...numbers); 
+ // initialize counter 
+ for (i = 0; i <= max; i++) { 
+    count[i] = 0; 
+ } 
+ for (i=0; i < numbers.length; i++) { 
+    count[numbers[i]]++; 
+ } 
+ for (i = 0; i <= max; i++) { 
+    while (count[i]-- > 0) { 
+        numbers[z++] = i; 
+    } 
+ } 
+ // output sorted array 
+ for (i=0; i < numbers.length; i++) { 
+    console.log(numbers[i]); 
+ } 
+
+```

guide/russian/algorithms/sorting-algorithms/heap-sort/index.md

@@ -0,0 +1,133 @@
+---
+title: Heapsort
+localeTitle: Пирамидальная сортировка
+---
+## Пирамидальная сортировка
+
+Heapsort - эффективный алгоритм сортировки, основанный на использовании кучи max / min. Куча - это древовидная структура данных, которая удовлетворяет свойству кучи - то есть для максимальной кучи, ключ любого узла меньше или равен ключу его родителя (если у него есть родительский элемент). Это свойство можно использовать для доступа к максимальному элементу в куче в времени O (logn) с использованием метода maxHeapify. Мы выполняем эту операцию n раз, каждый раз перемещая максимальный элемент в куче до вершины кучи и извлекаем ее из кучи и сортировать массив. Таким образом, после n итераций мы будем иметь отсортированную версию входного массива. Этот алгоритм работает в O (nlogn) времени и O (1) дополнительное пространство \[O (n), включая пространство, необходимое для хранения входных данных\], поскольку все операции выполняются полностью на месте.
+
+Наихудшим и средним по времени случаем Хэпсорт является O (nlogn). Несмотря на то, что у heapsort есть более худшая сложность, чем quicksort, хорошо реализованная quicksort работает быстрее на практике. Это алгоритм на основе сравнения, поэтому его можно использовать для нечетных наборов данных, поскольку для элементов может быть определено некоторое отношение (свойство кучи).
+
+Реализация на Java приведена ниже:
+
+```java
+import java.util.Arrays; 
+ public class Heapsort { 
+ 
+    public static void main(String[] args) { 
+        //test array 
+        Integer[] arr = {1, 4, 3, 2, 64, 3, 2, 4, 5, 5, 2, 12, 14, 5, 3, 0, -1}; 
+        String[] strarr = {"hope you find this helpful!", "wef", "rg", "q2rq2r", "avs", "erhijer0g", "ewofij", "gwe", "q", "random"}; 
+        arr = heapsort(arr); 
+        strarr = heapsort(strarr); 
+        System.out.println(Arrays.toString(arr)); 
+        System.out.println(Arrays.toString(strarr)); 
+    } 
+ 
+    //O(nlogn) TIME, O(1) SPACE, NOT STABLE 
+    public static <E extends Comparable<E>> E[] heapsort(E[] arr){ 
+        int heaplength = arr.length; 
+        for(int i = arr.length/2; i>0;i--){ 
+            arr = maxheapify(arr, i, heaplength); 
+        } 
+ 
+        for(int i=arr.length-1;i>=0;i--){ 
+            E max = arr[0]; 
+            arr[0] = arr[i]; 
+            arr[i] = max; 
+            heaplength--; 
+            arr = maxheapify(arr, 1, heaplength); 
+        } 
+ 
+        return arr; 
+    } 
+ 
+    //Creates maxheap from array 
+    public static <E extends Comparable<E>> E[] maxheapify(E[] arr, Integer node, Integer heaplength){ 
+        Integer left = node*2; 
+        Integer right = node*2+1; 
+        Integer largest = node; 
+ 
+        if(left.compareTo(heaplength) <=0 && arr[left-1].compareTo(arr[node-1]) >= 0){ 
+            largest = left; 
+        } 
+        if(right.compareTo(heaplength) <= 0 && arr[right-1].compareTo(arr[largest-1]) >= 0){ 
+            largest = right; 
+        } 
+        if(largest != node){ 
+            E temp = arr[node-1]; 
+            arr[node-1] = arr[largest-1]; 
+            arr[largest-1] = temp; 
+            maxheapify(arr, largest, heaplength); 
+        } 
+        return arr; 
+    } 
+ } 
+```
+
+реализация в C ++
+
+```C++
+#include <iostream> 
+ using namespace std; 
+ void heapify(int arr[], int n, int i) 
+ { 
+    int largest = i; 
+    int l = 2*i + 1; 
+    int r = 2*i + 2; 
+    if (l < n && arr[l] > arr[largest]) 
+        largest = l; 
+    if (r < n && arr[r] > arr[largest]) 
+        largest = r; 
+    if (largest != i) 
+    { 
+        swap(arr[i], arr[largest]); 
+ 
+ 
+        heapify(arr, n, largest); 
+    } 
+ } 
+ 
+ 
+ void heapSort(int arr[], int n) 
+ { 
+ 
+    for (int i = n / 2 - 1; i >= 0; i--) 
+        heapify(arr, n, i); 
+ 
+ 
+    for (int i=n-1; i>=0; i--) 
+    { 
+ 
+        swap(arr[0], arr[i]); 
+ 
+ 
+        heapify(arr, i, 0); 
+    } 
+ } 
+ void printArray(int arr[], int n) 
+ { 
+    for (int i=0; i<n; ++i) 
+        cout << arr[i] << " "; 
+    cout << "\n"; 
+ } 
+ int main() 
+ { 
+    int arr[] = {12, 11, 13, 5, 6, 7}; 
+    int n = sizeof(arr)/sizeof(arr[0]); 
+ 
+    heapSort(arr, n); 
+ 
+    cout << "Sorted array is \n"; 
+    printArray(arr, n); 
+ } 
+```
+
+### Визуализация
+
+*   [USFCA](https://www.cs.usfca.edu/~galles/visualization/HeapSort.html)
+*   [HackerEarth](https://www.hackerearth.com/practice/algorithms/sorting/heap-sort/tutorial/)
+
+#### Дополнительная информация:
+
+*   [Википедия](https://en.wikipedia.org/wiki/Quicksort)

guide/russian/algorithms/sorting-algorithms/index.md

@@ -0,0 +1,54 @@
+---
+title: Sorting Algorithms
+localeTitle: Алгоритмы сортировки
+---
+## Алгоритмы сортировки
+
+Алгоритмы сортировки - это набор инструкций, которые принимают массив или список в качестве ввода и упорядочивают элементы в определенном порядке.
+
+Сорта чаще всего относятся к числу или форме алфавитного (называемого лексикографического) порядка и могут быть в порядке возрастания (AZ, 0-9) или нисходящего (ZA, 9-0).
+
+### Почему алгоритмы сортировки важны
+
+Поскольку сортировка часто может уменьшить сложность проблемы, это важный алгоритм в области компьютерных наук. Эти алгоритмы имеют прямые приложения в алгоритмах поиска, алгоритмах баз данных, методах разделения и захвата, алгоритмах структуры данных и многом другом.
+
+### Некоторые общие алгоритмы сортировки
+
+Некоторые из наиболее распространенных алгоритмов сортировки:
+
+*   Выбор Сортировка
+*   Сортировка пузырьков
+*   Вставка Сортировка
+*   Сортировка слиянием
+*   Быстрая сортировка
+*   Куча сортировки
+*   Подсчет сортировки
+*   Radix Sort
+*   Сортировать по
+
+### Классификация алгоритма сортировки
+
+Алгоритмы сортировки могут быть классифицированы на основе следующих параметров:
+
+1.  Основано на количестве свопов или инверсии Это количество раз, когда алгоритм свопит элементы для сортировки ввода. `Selection Sort` требуется минимальное количество свопов.
+    
+2.  Основано на количестве сравнений Это число раз, когда алгоритм сравнивает элементы для сортировки ввода. Используя [нотацию Big-O](https://guide.freecodecamp.org/computer-science/notation/big-o-notation/) , приведенные выше примеры алгоритма сортировки требуют, по крайней мере, `O(nlogn)` сравнений в наилучшем случае и сравнения `O(n^2)` в худшем случае для большинства выходов.
+    
+3.  На основе рекурсии или нерекурсии Некоторые алгоритмы сортировки, такие как `Quick Sort` , используют рекурсивные методы для сортировки ввода. Другие алгоритмы сортировки, такие как `Selection Sort` или `Insertion Sort` , используют нерекурсивные методы. Наконец, некоторые алгоритмы сортировки, такие как `Merge Sort` , используют как рекурсивные, так и нерекурсивные методы для сортировки ввода.
+    
+4.  Основываясь на стабильности Алгоритмы сортировки считаются `stable` если алгоритм поддерживает относительный порядок элементов с равными ключами. Другими словами, два эквивалентных элемента остаются в том же порядке на отсортированном выходе, что и на входе.
+    
+
+*   `Insertion sort` `Merge Sort` `Bubble Sort` стабильны
+*   `Heap Sort` и `Quick Sort` нестабильны
+
+1.  Основываясь на дополнительных требованиях к пространству Говорят, что алгоритмы сортировки находятся на `in place` если им требуется постоянное `O(1)` дополнительное пространство для сортировки.
+
+*   `Insertion sort` и `Quick-sort` находятся `in place` своего рода , как мы перемещаем элементы относительно оси поворота и на самом деле не использовать отдельный массив , который не имеет места в сортировках слияния , где размер входа должен быть выделен заранее , чтобы сохранить выход во время Сортировать.
+    
+*   `Merge Sort` - пример сортировки `out place` поскольку для его операций требуется дополнительное пространство памяти.
+    
+
+### Наилучшая возможная временная сложность для любой сортировки на основе сравнения
+
+Любой алгоритм сортировки, основанный на сравнении, должен производить, по меньшей мере, сравнение nLog2n для сортировки входного массива, а сортировка Heapsort и merge - это асимптотически оптимальные сортировки сортировки. Это можно легко доказать, построив диаграмму дерева desicion.

guide/russian/algorithms/sorting-algorithms/insertion-sort/index.md

@@ -0,0 +1,191 @@
+---
+title: Insertion Sort
+localeTitle: Вставка Сортировка
+---
+## Вставка Сортировка
+
+Сортировка вставки - это самый простой и эффективный алгоритм сортировки для небольшого числа элементов.
+
+### Пример:
+
+В сортировке Insertion вы сравниваете `key` элемент с предыдущими элементами. Если предыдущие элементы больше `key` элемента, вы перемещаете предыдущий элемент в следующую позицию.
+
+Начните с индекса 1 до размера входного массива.
+
+\[8 3 5 1 4 2\]
+
+Шаг 1 :
+
+! [\[8 3 5 1 4 2\]](https://github.com/blulion/freecodecamp-resource/blob/master/insertion_sort/1.png?raw=true)
+```
+      key = 3 //starting from 1st index. 
+ 
+      Here `key` will be compared with the previous elements. 
+ 
+      In this case, `key` is compared with 8. since 8 > 3, move the element 8 
+      to the next position and insert `key` to the previous position. 
+ 
+      Result: [ 3 8 5 1 4 2 ] 
+```
+
+Шаг 2 :
+
+! [\[3 8 5 1 4 2\]](https://github.com/blulion/freecodecamp-resource/blob/master/insertion_sort/2.png?raw=true)
+```
+      key = 5 //2nd index 
+ 
+      8 > 5 //move 8 to 2nd index and insert 5 to the 1st index. 
+ 
+      Result: [ 3 5 8 1 4 2 ] 
+```
+
+Шаг 3 :
+
+! [\[3 5 8 1 4 2\]](https://github.com/blulion/freecodecamp-resource/blob/master/insertion_sort/3.png?raw=true)
+```
+      key = 1 //3rd index 
+ 
+      8 > 1     => [ 3 5 1 8 4 2 ] 
+ 
+      5 > 1     => [ 3 1 5 8 4 2 ] 
+ 
+      3 > 1     => [ 1 3 5 8 4 2 ] 
+ 
+      Result: [ 1 3 5 8 4 2 ] 
+```
+
+Шаг 4:
+
+! [\[1 3 5 8 4 2\]](https://github.com/blulion/freecodecamp-resource/blob/master/insertion_sort/4.png?raw=true)
+```
+      key = 4 //4th index 
+ 
+      8 > 4   => [ 1 3 5 4 8 2 ] 
+ 
+      5 > 4   => [ 1 3 4 5 8 2 ] 
+ 
+      3 > 4   ≠>  stop 
+ 
+      Result: [ 1 3 4 5 8 2 ] 
+```
+
+Шаг 5:
+
+! [\[1 3 4 5 8 2\]](https://github.com/blulion/freecodecamp-resource/blob/master/insertion_sort/5.png?raw=true)
+```
+      key = 2 //5th index 
+ 
+      8 > 2   => [ 1 3 4 5 2 8 ] 
+ 
+      5 > 2   => [ 1 3 4 2 5 8 ] 
+ 
+      4 > 2   => [ 1 3 2 4 5 8 ] 
+ 
+      3 > 2   => [ 1 2 3 4 5 8 ] 
+ 
+      1 > 2   ≠> stop 
+ 
+      Result: [1 2 3 4 5 8] 
+```
+
+! [\[1 2 3 4 5 8\]](https://github.com/blulion/freecodecamp-resource/blob/master/insertion_sort/6.png?raw=true)
+
+Ниже алгоритм немного оптимизирован, чтобы избежать замены `key` элемента на каждой итерации. Здесь `key` элемент будет заменен в конце итерации (шаг).
+
+```Algorithm
+    InsertionSort(arr[]) 
+      for j = 1 to arr.length 
+         key = arr[j] 
+         i = j - 1 
+         while i > 0 and arr[i] > key 
+            arr[i+1] = arr[i] 
+            i = i - 1 
+         arr[i+1] = key 
+```
+
+Вот детальная реализация в Javascript:
+```
+function insertion_sort(A) { 
+    var len = array_length(A); 
+    var i = 1; 
+    while (i < len) { 
+        var x = A[i]; 
+        var j = i - 1; 
+        while (j >= 0 && A[j] > x) { 
+            A[j + 1] = A[j]; 
+            j = j - 1; 
+        } 
+        A[j+1] = x; 
+        i = i + 1; 
+    } 
+ } 
+```
+
+Быстрая реализация в Swift приведена ниже:
+
+```swift
+  var array = [8, 3, 5, 1, 4, 2] 
+ 
+  func insertionSort(array:inout Array<Int>) -> Array<Int>{ 
+      for j in 0..<array.count { 
+          let key = array[j] 
+          var i = j-1 
+ 
+          while (i > 0 && array[i] > key){ 
+              array[i+1] = array[i] 
+              i = i-1 
+          } 
+          array[i+1] = key 
+      } 
+      return array 
+  } 
+```
+
+Пример Java приведен ниже:
+```
+public int[] insertionSort(int[] arr) 
+      for (j = 1; j < arr.length; j++) { 
+         int key = arr[j] 
+         int i = j - 1 
+         while (i > 0 and arr[i] > key) { 
+            arr[i+1] = arr[i] 
+            i -= 1 
+         } 
+         arr[i+1] = key 
+      } 
+      return arr; 
+```
+
+### inserting сорт в c ....
+
+```C
+void insertionSort(int arr[], int n) 
+ { 
+   int i, key, j; 
+   for (i = 1; i < n; i++) 
+   { 
+       key = arr[i]; 
+       j = i-1; 
+       while (j >= 0 && arr[j] > key) 
+       { 
+           arr[j+1] = arr[j]; 
+           j = j-1; 
+       } 
+       arr[j+1] = key; 
+   } 
+ } 
+```
+
+### Свойства:
+
+*   Космическая сложность: O (1)
+*   Сложность времени: O (n), O (n \* n), O (n \* n) для лучших, средних, худших случаев соответственно
+*   Сортировка на месте: Да
+*   Стабильный: Да
+
+#### Другие источники:
+
+*   [Википедия](https://en.wikipedia.org/wiki/Insertion_sort)
+*   [CS50 - YouTube](https://youtu.be/TwGb6ohsvUU)
+*   [SortInsertion - GeeksforGeeks, YouTube](https://www.youtube.com/watch?v=wObxd4Kx8sE)
+*   [Вставка Сортировка Визуализация](https://www.hackerearth.com/practice/algorithms/sorting/insertion-sort/visualize/)

guide/russian/algorithms/sorting-algorithms/merge-sort/index.md

@@ -0,0 +1,204 @@
+---
+title: Merge Sort
+localeTitle: Объединить сортировку
+---
+## Сортировка слиянием
+
+Merge Sort - алгоритм [Divide и Conquer](https://guide.freecodecamp.org/algorithms/divide-and-conquer-algorithms) . Он делит входной массив на две половины, вызывает себя для двух половинок, а затем объединяет две отсортированные половинки. Основная часть алгоритма дается двумя отсортированными массивами, мы должны объединить их в один отсортированный массив. Существует нечто, известное как « [Алгоритм](http://www.geeksforgeeks.org/merge-two-sorted-arrays/) с [двумя пальцами»,](http://www.geeksforgeeks.org/merge-two-sorted-arrays/) который помогает нам объединить два отсортированных массива вместе. Используя эту подпрограмму и вызывая функцию сортировки слияния на ребрах массива, мы дадим окончательный отсортированный массив, который мы ищем.
+
+Так как это алгоритм, основанный на рекурсии, у нас есть рекуррентное соотношение для него. Рекуррентное отношение - это просто способ представления проблемы в терминах ее подзадач.
+
+`T(n) = 2 * T(n / 2) + O(n)`
+
+Поставив это на простом английском языке, мы разбиваем подзадачу на две части на каждом шагу, и у нас есть некоторый линейный объем работы, который мы должны сделать для слияния двух отсортированных половин на каждом шаге.
+```
+T(n) = 2T(n/2) + n 
+     = 2(2T(n/4) + n/2) + n 
+     = 4T(n/4) + n + n 
+     = 4(2T(n/8) + n/4) + n + n 
+     = 8T(n/8) + n + n + n 
+     = nT(n/n) + n + ... + n + n + n 
+     = n + n + ... + n + n + n 
+```
+
+Подсчитая количество повторений n в сумме в конце, мы видим, что есть lg n + 1 из них. Таким образом, время работы n (lg n + 1) = n lg n + n. Заметим, что n lg n + n <n lg n + n lg n = 2n lg n при n> 0, поэтому время работы O (n lg n).
+
+```Algorithm
+MergeSort(arr[], left,  right): 
+ If right > l: 
+     1. Find the middle point to divide the array into two halves: 
+             mid = (left+right)/2 
+     2. Call mergeSort for first half: 
+             Call mergeSort(arr, left, mid) 
+     3. Call mergeSort for second half: 
+             Call mergeSort(arr, mid+1, right) 
+     4. Merge the two halves sorted in step 2 and 3: 
+             Call merge(arr, left, mid, right) 
+ ``` 
+ 
+ ![Merge Sort Algorithm](https://upload.wikimedia.org/wikipedia/commons/thumb/e/e6/Merge_sort_algorithm_diagram.svg/300px-Merge_sort_algorithm_diagram.svg.png) 
+ 
+ ### Properties: 
+ * Space Complexity: O(n) 
+ * Time Complexity: O(n*log(n)). The time complexity for the Merge Sort might not be obvious from the first glance. The log(n) factor that comes in is because of the recurrence relation we have mentioned before. 
+ * Sorting In Place: No in a typical implementation 
+ * Stable: Yes 
+ * Parallelizable :yes (Several parallel variants are discussed in the third edition of Cormen, Leiserson, Rivest, and Stein's Introduction to Algorithms.) 
+ 
+ ### Visualization: 
+ * <a href='https://www.cs.usfca.edu/~galles/visualization/ComparisonSort.html'>USFCA</a> 
+ * <a href='https://www.hackerearth.com/practice/algorithms/sorting/merge-sort/visualize/'>HackerEarth</a> 
+ 
+ 
+ ### Relavant videos on freeCodeCamp YouTube channel 
+ * <a href='https://youtu.be/TzeBrDU-JaY'>Merge Sort algorithm - MyCodeSchool</a> 
+ 
+ ### Other Resources: 
+ * <a href='https://en.wikipedia.org/wiki/Merge_sort' target='_blank' rel='nofollow'>Wikipedia</a> 
+ * <a href='www.geeksforgeeks.org/merge-sort' target='_blank' rel='nofollow'>GeeksForGeeks</a> 
+ * <a href='https://youtu.be/sWtYJv_YXbo' target='_blank' rel='nofollow'>Merge Sort - CS50</a> 
+ 
+ ### Implementaion in JS 
+```
+
+JS const list = \[23, 4, 42, 15, 16, 8, 3\]
+
+const mergeSort = (list) => { if (list.length <= 1) возвращаемый список; const средний = list.length / 2; const left = list.slice (0, средний); const right = list.slice (средний, list.length); return merge (mergeSort (слева), mergeSort (справа)); }
+
+const merge = (слева, справа) => { var result = \[\]; while (left.length || right.length) { if (left.length && right.length) { if (left \[0\] <right \[0\]) { result.push (left.shift ()) } else { result.push (right.shift ()) } } else if (left.length) { result.push (left.shift ()) } else { result.push (right.shift ()) } } результат возврата; }
+
+console.log (mergeSort (список)) // \[3, 4, 8, 15, 16, 23, 42\]
+```
+### Implementation in C 
+```
+
+С
+
+# включают
+
+# включают
+
+void merge (int arr \[\], int l, int m, int r) { int i, j, k; int n1 = m - l + 1; int n2 = r - m;
+```
+int L[n1], R[n2]; 
+ 
+ for (i = 0; i < n1; i++) 
+    L[i] = arr[l + i]; 
+ for (j = 0; j < n2; j++) 
+    R[j] = arr[m + 1+ j]; 
+ i = 0; 
+ j = 0; 
+ k = l; 
+ while (i < n1 && j < n2) 
+ { 
+    if (L[i] <= R[j]) 
+    { 
+        arr[k] = L[i]; 
+        i++; 
+    } 
+    else 
+    { 
+        arr[k] = R[j]; 
+        j++; 
+    } 
+    k++; 
+ } 
+ 
+ 
+ while (i < n1) 
+ { 
+    arr[k] = L[i]; 
+    i++; 
+    k++; 
+ } 
+ 
+ while (j < n2) 
+ { 
+    arr[k] = R[j]; 
+    j++; 
+    k++; 
+ } 
+```
+
+}
+
+void mergeSort (int arr \[\], int l, int r) { если (l <r) {  
+int m = l + (rl) / 2;
+```
+    mergeSort(arr, l, m); 
+    mergeSort(arr, m+1, r); 
+ 
+    merge(arr, l, m, r); 
+ } 
+```
+
+} void printArray (int A \[\], int size) { int i; для (i = 0; i <size; i ++) printf ("% d", A \[i\]); Е ( "\\ п"); } int main () { int arr \[\] = {12, 11, 13, 5, 6, 7}; int arr\_size = sizeof (arr) / sizeof (arr \[0\]);
+```
+printf("Given array is \n"); 
+ printArray(arr, arr_size); 
+ 
+ mergeSort(arr, 0, arr_size - 1); 
+ 
+ printf("\nSorted array is \n"); 
+ printArray(arr, arr_size); 
+ return 0; 
+```
+
+```
+### Implementation in C++ 
+ 
+ Let us consider array A = {2,5,7,8,9,12,13} 
+ and array B = {3,5,6,9,15} and we want array C to be in ascending order as well. 
+```
+
+C ++ void mergesort (int A \[\], int size _a, int B \[\], int size_ b, int C \[\]) { int token _a, токен_ b, токен _c; for (токен_ a = 0, токен _b = 0, токен_ c = 0, токен _a_ _a && токен _b__ __б; ) { если (A \[токен _a\] <= B \[токен_ b\]) C \[токен _c ++\] = A \[токен_ a ++\]; еще C \[токен _c ++\] = B \[токен_ b ++\]; }__
+```
+  if(token_a<size_a) 
+  { 
+      while(token_a<size_a) 
+           C[token_c++]=A[token_a++]; 
+  } 
+  else 
+  { 
+      while(token_b<size_b) 
+           C[token_c++]=B[token_b++]; 
+  } 
+```
+
+}
+```
+### Implementation in Python 
+```
+
+питон temp = None def merge (arr, слева, справа): глобальные темпы, инверсии mid = (left + right) // 2 для i в диапазоне (слева, справа + 1): temp \[i\] = arr \[i\]
+```
+k, L, R = left, left, mid + 1 
+ while L <= mid and R <= right: 
+    if temp[L] <= temp[R]: 
+        arr[k] = temp[L] 
+        L += 1 
+    else: 
+        arr[k] = temp[R] 
+        R += 1 
+    k += 1 
+ 
+ while L <= mid: 
+    arr[k] = temp[L] 
+    L += 1 
+    k += 1 
+ 
+ while R <= right: 
+    arr[k] = temp[R] 
+    R += 1 
+    k += 1 
+```
+
+def merge\_sort (arr, слева, справа): если left> = right: вернуть
+```
+mid = (left + right) // 2 
+ merge_sort(arr, left, mid) 
+ merge_sort(arr, mid + 1, right) 
+ merge(arr, left, right) 
+```
+
+arr = \[1,6,3,1,8,4,2,9,3\] temp = \[Нет для \_ в диапазоне (len (arr))\] merge\_sort (arr, 0, len (arr) - 1) print (arr, inversions) \`\` \`

guide/russian/algorithms/sorting-algorithms/quick-sort/index.md

@@ -0,0 +1,146 @@
+---
+title: Quick Sort
+localeTitle: Быстрая сортировка
+---
+## Быстрая сортировка
+
+Быстрая сортировка - эффективный алгоритм сортировки и разделения. Средняя временная сложность Quick Sort - O (nlog (n)) с наихудшей временной сложностью - O (n ^ 2).
+
+Шаги, связанные с Quick Sort:
+
+*   Выберите элемент, который будет служить точкой опоры, в этом случае последним элементом массива является опорная точка.
+*   Разделение: сортировка массива таким образом, чтобы все элементы, меньшие, чем точка поворота, находились влево, а все элементы, большие, чем точка поворота, находились вправо.
+*   Вызовите Quicksort рекурсивно, учитывая предыдущий шарнир, чтобы правильно разделить левый и правый массивы. (Более подробное объяснение можно найти в комментариях ниже)
+
+Быстрая реализация в JavaScript:
+
+```javascript
+const arr = [6, 2, 5, 3, 8, 7, 1, 4] 
+ 
+ const quickSort = (arr, start, end) => { 
+ 
+  if(start < end) { 
+ 
+    // You can learn about how the pivot value is derived in the comments below 
+    let pivot = partition(arr, start, end) 
+ 
+    // Make sure to read the below comments to understand why pivot - 1 and pivot + 1 are used 
+    // These are the recursive calls to quickSort 
+    quickSort(arr, start, pivot - 1) 
+    quickSort(arr, pivot + 1, end) 
+  } 
+ 
+ } 
+ 
+ const partition = (arr, start, end) => { 
+  let pivot = end 
+  // Set i to start - 1 so that it can access the first index in the event that the value at arr[0] is greater than arr[pivot] 
+  // Succeeding comments will expound upon the above comment 
+  let i = start - 1 
+  let j = start 
+ 
+  // Increment j up to the index preceding the pivot 
+  while (j < pivot) { 
+ 
+    // If the value is greater than the pivot increment j 
+    if (arr[j] > arr[pivot]) { 
+      j++ 
+    } 
+ 
+    // When the value at arr[j] is less than the pivot: 
+    // increment i (arr[i] will be a value greater than arr[pivot]) and swap the value at arr[i] and arr[j] 
+    else { 
+      i++ 
+      swap(arr, j, i) 
+      j++ 
+    } 
+ 
+  } 
+ 
+  //The value at arr[i + 1] will be greater than the value of arr[pivot] 
+  swap(arr, i + 1, pivot) 
+ 
+  //You return i + 1, as the values to the left of it are less than arr[i+1], and values to the right are greater than arr[i + 1] 
+  // As such, when the recursive quicksorts are called, the new sub arrays will not include this the previously used pivot value 
+  return i + 1 
+ } 
+ 
+ const swap = (arr, firstIndex, secondIndex) => { 
+  let temp = arr[firstIndex] 
+  arr[firstIndex] = arr[secondIndex] 
+  arr[secondIndex] = temp 
+ } 
+ 
+ quickSort(arr, 0, arr.length - 1) 
+ console.log(arr) 
+```
+
+Быстрая сортировка в C
+
+```C
+#include<stdio.h> 
+ void swap(int* a, int* b) 
+ { 
+    int t = *a; 
+    *a = *b; 
+    *b = t; 
+ } 
+ int partition (int arr[], int low, int high) 
+ { 
+    int pivot = arr[high]; 
+    int i = (low - 1); 
+ 
+    for (int j = low; j <= high- 1; j++) 
+    { 
+        if (arr[j] <= pivot) 
+        { 
+            i++; 
+            swap(&arr[i], &arr[j]); 
+        } 
+    } 
+    swap(&arr[i + 1], &arr[high]); 
+    return (i + 1); 
+ } 
+ void quickSort(int arr[], int low, int high) 
+ { 
+    if (low < high) 
+    { 
+        int pi = partition(arr, low, high); 
+ 
+        quickSort(arr, low, pi - 1); 
+        quickSort(arr, pi + 1, high); 
+    } 
+ } 
+ 
+ 
+ void printArray(int arr[], int size) 
+ { 
+    int i; 
+    for (i=0; i < size; i++) 
+        printf("%d ", arr[i]); 
+    printf("n"); 
+ } 
+ 
+ 
+ int main() 
+ { 
+    int arr[] = {10, 7, 8, 9, 1, 5}; 
+    int n = sizeof(arr)/sizeof(arr[0]); 
+    quickSort(arr, 0, n-1); 
+    printf("Sorted array: n"); 
+    printArray(arr, n); 
+    return 0; 
+ } 
+```
+
+Сложность пространства быстрой сортировки - O (n). Это улучшение по сравнению с другими алгоритмами сортировки и разделения, которые занимают пространство O (nlong (n)). Быстрая сортировка достигает этого, изменяя порядок элементов в заданном массиве. Сравните это с алгоритмом [сортировки слиянием](https://guide.freecodecamp.org/algorithms/sorting-algorithms/merge-sort) , который создает в каждом вызове функции 2 массива, каждая длина n / 2.
+
+#### Дополнительная информация:
+
+*   [Википедия](https://en.wikipedia.org/wiki/Quicksort)
+    
+*   [GeeksForGeeks](http://www.geeksforgeeks.org/quick-sort)
+    
+*   [Youtube: визуальное объяснение Quicksort](https://www.youtube.com/watch?v=MZaf_9IZCrc)
+    
+*   [Youtube: Gayle Laakmann McDowell (автор Cracking the Coding Interview) объясняет основы быстрой сортировки и демонстрирует некоторые реализации](https://www.youtube.com/watch?v=SLauY6PpjW4)

guide/russian/algorithms/sorting-algorithms/radix-sort/index.md

@@ -0,0 +1,111 @@
+---
+title: Radix Sort
+localeTitle: Radix Sort
+---
+## Radix Sort
+
+Предпосылки: подсчет сортировки
+
+QuickSort, MergeSort, HeapSort - это алгоритмы сортировки на основе сравнения. CountSort не является алгоритмом, основанным на сравнении. Он имеет сложность O (n + k), где k - максимальный элемент входного массива. Таким образом, если k является O (n), CountSort становится линейной сортировкой, что лучше, чем алгоритмы сортировки на основе сравнения, которые имеют сложность времени O (nlogn). Идея состоит в том, чтобы расширить алгоритм CountSort, чтобы получить лучшую временную сложность, когда k идет O (n2). Приходит идея Radix Sort.
+
+Алгоритм:
+
+Для каждой цифры i, где i изменяется от младшей значащей цифры до самой значащей цифры числа Сортировка массива ввода с использованием алгоритма countsort в соответствии с i-й цифрой. Мы использовали сортировку count, потому что это стабильный вид.
+
+Пример. Предположим, что входной массив:
+
+10,21,17,34,44,11,654,123
+
+На основе алгоритма мы сортируем входной массив в соответствии с его цифрой (наименьшая значащая цифра).
+
+0: 10  
+1: 21 11  
+2:  
+3: 123  
+4: 34 44 654  
+5:  
+6:  
+7: 17  
+8:  
+9:  
+
+Таким образом, массив становится 10,21,11,123,24,44,654,17 Теперь мы будем сортировать по десятизначной цифре:
+
+0:  
+1: 10 11 17  
+2: 21 123  
+3: 34  
+4: 44  
+5: 654  
+6:  
+7:  
+8:  
+9:
+
+Теперь массив становится следующим: 10,11,17,21,123,34,44,654 Наконец, мы сортируем по ста цифре (самая значительная цифра):
+
+0: 010 011 017 021 034 044  
+1: 123  
+2:  
+3:  
+4:  
+5:  
+6: 654  
+7:  
+8:  
+9:
+
+Массив становится: 10,11,17,21,34,44,123,654, который сортируется. Так работает наш алгоритм.
+
+Реализация в C:
+```
+void countsort(int arr[],int n,int place){ 
+ 
+        int i,freq[range]={0};         //range for integers is 10 as digits range from 0-9 
+ 
+        int output[n]; 
+ 
+        for(i=0;i<n;i++) 
+ 
+                freq[(arr[i]/place)%range]++; 
+ 
+        for(i=1;i<range;i++) 
+ 
+                freq[i]+=freq[i-1]; 
+ 
+        for(i=n-1;i>=0;i--){ 
+ 
+                output[freq[(arr[i]/place)%range]-1]=arr[i]; 
+ 
+                freq[(arr[i]/place)%range]--; 
+ 
+        } 
+ 
+        for(i=0;i<n;i++) 
+ 
+                arr[i]=output[i]; 
+ 
+ } 
+ 
+ void radixsort(ll arr[],int n,int maxx){            //maxx is the maximum element in the array 
+ 
+        int mul=1; 
+ 
+        while(maxx){ 
+ 
+                countsort(arr,n,mul); 
+ 
+                mul*=10; 
+ 
+                maxx/=10; 
+ 
+        } 
+ 
+ } 
+```
+
+### Дополнительная информация:
+
+*   [Википедия](https://en.wikipedia.org/wiki/Radix_sort)
+    
+*   [GeeksForGeeks](http://www.geeksforgeeks.org/radix-sort/)

guide/russian/algorithms/sorting-algorithms/selection-sort/index.md

@@ -0,0 +1,67 @@
+---
+title: Selection Sort
+localeTitle: Выбор Сортировка
+---
+## Выбор Сортировка
+
+Выбор Сортировка - один из самых простых алгоритмов сортировки. Он работает следующим образом,
+
+1.  Найдите наименьший элемент. Поменяйте его первым элементом.
+2.  Найдите второй наименьший элемент. Поменяйте его на второй элемент.
+3.  Найдите третий наименьший элемент. Поменяйте его третьим элементом.
+4.  Повторите поиск следующего наименьшего элемента и переместите его в соответствующее правильное положение до сортировки массива.
+
+Как вы можете догадаться, этот алгоритм называется Selection Sort, потому что он многократно выбирает следующий наименьший элемент и меняет его на свое место.
+
+Но как бы вы написали код для поиска индекса второго наименьшего значения в массиве?
+
+*   Легкий способ заметить, что наименьшее значение уже было заменено на индекс 0, поэтому проблема сводится к поиску наименьшего элемента в массиве, начиная с индекса 1.
+
+### Реализация в C / C ++
+
+```C
+for(int i = 0; i < n; i++) 
+ { 
+    int min_index = i; 
+    int min_element = a[i]; 
+ 
+    for(int j = i +1; j < n; j++) 
+    { 
+        if(a[j] < min_element) 
+        { 
+            min_element = a[j]; 
+            min_index = j; 
+        } 
+    } 
+ 
+    swap(&a[i], &a[min_index]); 
+ } 
+```
+
+### Реализация в Javascript
+
+\`\` \`Javascript _сортировка_ функции _(A) { var len =_ длина _массива_ (A); для (var i = 0; i <len - 1; i = i + 1) { var j _min = i; для (var j = i + 1; j <len; j = j + 1) { если (A \[j\] <A \[j_ min\]) { j _min = j; } else {} } if (j_ min! == i) { swap (A, i, j\_min); } else {} } }
+
+функция swap (A, x, y) { var temp = A \[x\]; A \[x\] = A \[y\]; A \[y\] = temp; }
+```
+### Implementation in Python 
+```
+
+питон def seletion _sort (arr): если не обр: return arr для i в диапазоне (len (arr)): min_ i = i для j в диапазоне (i + 1, len (arr)): если arr \[j\] <arr \[min _i\]: min_ i = j arr \[i\], arr \[min _i\] = arr \[min_ i\], arr \[i\] \`\` \`
+
+### свойства
+
+*   Космическая сложность: **O (n)**
+*   Сложность времени: **O (n 2 )**
+*   Сортировка на месте: **Да**
+*   Стабильный: **Нет**
+
+### Визуализация
+
+*   [USFCA](https://www.cs.usfca.edu/~galles/visualization/ComparisonSort.html)
+*   [HackerEarth](https://www.hackerearth.com/practice/algorithms/sorting/selection-sort/visualize/)
+
+### Рекомендации
+
+*   [Википедия](https://en.wikipedia.org/wiki/Selection_sort)
+*   [Академия Хана](https://www.khanacademy.org/computing/computer-science/algorithms#sorting-algorithms)

guide/russian/algorithms/sorting-algorithms/timsort/index.md

@@ -0,0 +1,112 @@
+---
+title: Timsort
+localeTitle: Timsort
+---
+## Timsort
+
+Timsort - это быстрый алгоритм сортировки, который работает при стабильной сложности O (N log (N))
+
+Timsort - это смесь в Sorting Sorting и Mergesort. Этот алгоритм реализован в Java Arrays.sort (), а также в отсортированных () и sort () Меньшая часть сортируется с помощью метода «Сортировка вставки» и позже объединяется с использованием Mergesort.
+
+Быстрая реализация в Python:
+```
+def binary_search(the_array, item, start, end): 
+    if start == end: 
+        if the_array[start] > item: 
+            return start 
+        else: 
+            return start + 1 
+    if start > end: 
+        return start 
+ 
+    mid = round((start + end)/ 2) 
+ 
+    if the_array[mid] < item: 
+        return binary_search(the_array, item, mid + 1, end) 
+ 
+    elif the_array[mid] > item: 
+        return binary_search(the_array, item, start, mid - 1) 
+ 
+    else: 
+        return mid 
+ 
+ """ 
+ Insertion sort that timsort uses if the array size is small or if 
+ the size of the "run" is small 
+ """ 
+ def insertion_sort(the_array): 
+    l = len(the_array) 
+    for index in range(1, l): 
+        value = the_array[index] 
+        pos = binary_search(the_array, value, 0, index - 1) 
+        the_array = the_array[:pos] + [value] + the_array[pos:index] + the_array[index+1:] 
+    return the_array 
+ 
+ def merge(left, right): 
+    """Takes two sorted lists and returns a single sorted list by comparing the 
+    elements one at a time. 
+    [1, 2, 3, 4, 5, 6] 
+    """ 
+    if not left: 
+        return right 
+    if not right: 
+        return left 
+    if left[0] < right[0]: 
+        return [left[0]] + merge(left[1:], right) 
+    return [right[0]] + merge(left, right[1:]) 
+ 
+ def timsort(the_array): 
+    runs, sorted_runs = [], [] 
+    length = len(the_array) 
+    new_run = [the_array[0]] 
+ 
+    # for every i in the range of 1 to length of array 
+    for i in range(1, length): 
+        # if i is at the end of the list 
+        if i == length - 1: 
+            new_run.append(the_array[i]) 
+            runs.append(new_run) 
+            break 
+        # if the i'th element of the array is less than the one before it 
+        if the_array[i] < the_array[i-1]: 
+            # if new_run is set to None (NULL) 
+            if not new_run: 
+                runs.append([the_array[i]]) 
+                new_run.append(the_array[i]) 
+            else: 
+                runs.append(new_run) 
+                new_run = [] 
+        # else if its equal to or more than 
+        else: 
+            new_run.append(the_array[i]) 
+ 
+    # for every item in runs, append it using insertion sort 
+    for item in runs: 
+        sorted_runs.append(insertion_sort(item)) 
+ 
+    # for every run in sorted_runs, merge them 
+    sorted_array = [] 
+    for run in sorted_runs: 
+        sorted_array = merge(sorted_array, run) 
+ 
+    print(sorted_array) 
+ 
+ timsort([2, 3, 1, 5, 6, 7]) 
+```
+
+#### Сложность:
+
+Сорт Tim имеет стабильную сложность O (N log (N)) и очень хорошо сравнивается с Quicksort. На этой [диаграмме](https://cdn-images-1.medium.com/max/1600/1*1CkG3c4mZGswDShAV9eHbQ.png) можно найти совпадение сложностей
+
+#### Дополнительная информация:
+
+*   [Википедия](https://en.wikipedia.org/wiki/Timsort)
+    
+*   [GeeksForGeeks](https://www.geeksforgeeks.org/timsort/)
+    
+*   [Youtube: визуальное объяснение Quicksort](https://www.youtube.com/watch?v=jVXsjswWo44)
+    
+
+#### Кредиты:
+
+[Реализация Python](https://hackernoon.com/timsort-the-fastest-sorting-algorithm-youve-never-heard-of-36b28417f399)