fix(guide): simplify directory structure

guide/russian/algorithms/search-algorithms/binary-search/index.md

@@ -0,0 +1,268 @@
+---
+title: Binary Search
+localeTitle: Двоичный поиск
+---
+## Двоичный поиск
+
+Двоичный поиск обнаруживает элемент в отсортированном массиве путем многократного деления интервала поиска пополам.
+
+Как искать имя в телефонной книге?
+
+Один из способов - начать с первой страницы и посмотреть на каждое имя в телефонной книге, пока мы не найдем то, что ищем. Но это был бы чрезвычайно трудоемкий и неэффективный способ поиска.
+
+Поскольку мы знаем, что имена в телефонной книге отсортированы в алфавитном порядке, мы, вероятно, могли бы выполнить следующие шаги:
+
+1.  Откройте среднюю страницу телефонной книги
+2.  Если у нас есть имя, которое мы ищем, мы закончили!
+3.  В противном случае отбросьте половину телефонной книги, которая не содержит имени
+4.  Повторяйте до тех пор, пока вы не найдете имя или больше страниц осталось в телефонной книге
+
+Сложность времени. Поскольку мы удаляем одну часть случая поиска на каждом этапе бинарного поиска и выполняем операцию поиска в другой половине, это приводит к худшей временной сложности _O_ ( _log 2 N_ ).
+
+Космическая сложность: двоичный поиск принимает постоянное или _O_ ( _1_ ) пространство, что означает, что мы не определяем какую-либо переменную, зависящую от размера ввода.
+
+для небольших наборов линейный поиск лучше, но в более крупных методах более эффективно использовать двоичный поиск.
+
+В деталях, сколько раз вы можете разделить N на 2, пока не получите 1? По сути, это означает, что вы выполняете двоичный поиск (половина элементов), пока не найдете его. В формуле это будет следующим:
+```
+1 = N / 2x 
+```
+
+Умножить на 2x:
+```
+2x = N 
+```
+
+Теперь сделайте log2:
+```
+log2(2x)    = log2 N 
+ x * log2(2) = log2 N 
+ x * 1       = log2 N 
+```
+
+Это означает, что вы можете разделить log N раз, пока не разделите все. Это означает, что вам нужно разделить лог N («выполнить шаг двоичного поиска»), пока не найдете свой элемент.
+
+_O_ ( _log 2 N_ ) такова, что на каждом шаге половина элементов в наборе данных ушла, что оправдано основанием логарифмической функции.
+
+Это алгоритм двоичного поиска. Он элегантен и эффективен, но для правильной работы массив должен быть **отсортирован** .
+
+* * *
+
+Найдите 5 в заданном массиве чисел, используя двоичный поиск.
+
+![Двоичный поиск 1](https://i.imgur.com/QAuugOL.jpg)
+
+Отметьте низкие, высокие и средние позиции в массиве.
+
+![Двоичный поиск 2](https://i.imgur.com/1710fEx.jpg)
+
+Сравните элемент, который вы ищете, с помощью среднего элемента.
+
+![Двоичный поиск 3](https://i.imgur.com/jr4icze.jpg)
+
+Выбросьте левую половину и посмотрите в правую половину.
+
+![Двоичный поиск 4](https://i.imgur.com/W57lGsk.jpg)
+
+Снова сравните с средним элементом.
+
+![Двоичный поиск 5](https://i.imgur.com/5Twm8NE.jpg)
+
+Теперь перейдите в левую половину.
+
+![Двоичный поиск 6](https://i.imgur.com/01xetay.jpg)
+
+Средний элемент - это тот элемент, который мы искали!
+
+Алгоритм бинарного поиска использует подход «разделяй и властвуй», где массив непрерывно делится до тех пор, пока элемент не будет найден или пока не останется больше элементов для проверки. Следовательно, этот алгоритм может быть определен рекурсивно для создания элегантного решения.
+
+Два базовых случая для рекурсии:
+
+*   В массиве осталось больше элементов
+*   Элемент найден
+
+Сила двоичного поиска в системах данных (деревья B +): Деревья двоичного поиска очень мощные из-за их времени поиска O (log n), во-вторых, для структуры данных hashmap, которая использует ключ ключа для поиска данных в O (1). Важно понимать, как время выполнения журнала n поступает с высоты двоичного дерева поиска. Если каждый узел разбит на два узла (двоичный), то глубина дерева будет log n (база 2). Чтобы улучшить эту скорость в Data System, мы используем деревья B +, потому что они имеют больший коэффициент ветвления и поэтому больше высота. Я надеюсь, что эта короткая статья поможет вам разобраться в том, как бинарный поиск используется в практических системах.
+
+Код для рекурсивного двоичного поиска показан ниже:
+
+### Реализация Javascript
+
+```javascript
+function binarySearch(arr, item, low, high) { 
+    if (low > high) { // No more elements in the array. 
+        return null; 
+    } 
+ 
+    // Find the middle of the array. 
+    var mid = Math.ceil((low + high) / 2); 
+ 
+    if (arr[mid] === item) { // Found the item! 
+        return mid; 
+    } 
+ 
+    if (item < arr[mid]) { // Item is in the half from low to mid-1. 
+        return binarySearch(arr, item, low, mid-1); 
+    } 
+ 
+    else { // Item is in the half from mid+1 to high. 
+        return binarySearch(arr, item, mid+1, high); 
+    } 
+ } 
+ 
+ var numbers = [1,2,3,4,5,6,7]; 
+ print(binarySearch(numbers, 5, 0, numbers.length-1)); 
+```
+
+Вот еще одна реализация в Javascript:
+
+```Javascript
+function binary_search(a, v) { 
+    function search(low, high) { 
+        if (low === high) { 
+            return a[low] === v; 
+        } else { 
+            var mid = math_floor((low + high) / 2); 
+            return (v === a[mid]) 
+                   || 
+                   (v < a[mid]) 
+                   ? search(low, mid - 1) 
+                   : search(mid + 1, high); 
+        } 
+    } 
+    return search(0, array_length(a) - 1); 
+ } 
+```
+
+### Реализация Ruby
+
+```ruby
+def binary_search(target, array) 
+  sorted_array = array.sort 
+  low = 0 
+  high = (sorted_array.length) - 1 
+ 
+  while high >= low 
+    middle = (low + high) / 2 
+ 
+    if target > sorted_array[middle] 
+      low = middle + 1 
+    elsif target < sorted_array[middle] 
+      high = middle - 1 
+    else 
+      return middle 
+    end 
+  end 
+  return nil 
+ end 
+```
+
+### Пример в C
+
+```C
+int binarySearch(int a[], int l, int r, int x) { 
+   if (r >= l){ 
+        int mid = l + (r - l)/2; 
+        if (a[mid] == x) 
+            return mid; 
+        if (arr[mid] > x) 
+            return binarySearch(arr, l, mid-1, x); 
+        return binarySearch(arr, mid+1, r, x); 
+   } 
+   return -1; 
+ } 
+```
+
+### Реализация C / C ++
+
+```C++
+int binary_search(int arr[], int l, int r, int target) 
+ { 
+   if (r >= l) 
+   { 
+        int mid = l + (r - l)/2; 
+        if (arr[mid] == target) 
+            return mid; 
+        if (arr[mid] > target) 
+            return binary_search(arr, l, mid-1, target); 
+        return binary_search(arr, mid+1, r, target); 
+   } 
+   return -1; 
+ } 
+```
+
+### Реализация Python
+
+```Python
+def binary_search(arr, l, r, target): 
+    if r >= l: 
+        mid = l + (r - l)/2 
+        if arr[mid] == target: 
+            return mid 
+        elif arr[mid] > target: 
+            return binary_search(arr, l, mid-1, target) 
+        else: 
+            return binary_search(arr, mid+1, r, target) 
+    else: 
+        return -1 
+```
+
+### Пример в C ++
+
+```c++
+// Binary Search using iteration 
+ int binary_search(int arr[], int beg, int end, int num) 
+ { 
+    while(beg <= end){ 
+        int mid = (beg + end) / 2; 
+        if(arr[mid] == num) 
+            return mid; 
+        else if(arr[mid] < num) 
+            beg = mid + 1; 
+        else 
+            end = mid - 1; 
+    } 
+    return -1; 
+ } 
+```
+
+```c++
+// Binary Search using recursion 
+ int binary_search(int arr[], int beg, int end, int num) 
+ { 
+    if(beg <= end){ 
+        int mid = (beg + end) / 2; 
+        if(arr[mid] == num) 
+            return mid; 
+        else if(arr[mid] < num) 
+            return binary_search(arr, mid + 1, end, num); 
+        else 
+            return binary_search(arr, beg, mid - 1, num); 
+    } 
+    return -1; 
+ } 
+```
+
+### Пример в C ++
+
+Рекурсивный подход!
+
+\`\` \`C ++ - Рекурсивный подход int binarySearch (int arr \[\], int start, int end, int x) { if (end> = start) { int mid = start + (end-start) / 2; if (arr \[mid\] == x)  
+возвращение в середине;
+```
+    if (arr[mid] > x) 
+        return binarySearch(arr, start, mid-1, x); 
+ 
+    return binarySearch(arr, mid+1, end, x); 
+```
+
+} return -1; }
+```
+Iterative approach! 
+```
+
+C ++ - Итеративный подход int binarySearch (int arr \[\], int start, int end, int x) { while (start <= end) { int mid = start + (end-start) / 2; if (arr \[mid\] == x) возвращение в середине; if (arr \[mid\] <x) start = mid + 1; еще end = mid - 1; } return -1; } \`\` \`
+
+### Больше информации
+
+*   [Бинарный поиск (видео на YouTube)](https://youtu.be/P3YID7liBug)
+*   [Двоичный поиск - CS50](https://www.youtube.com/watch?v=5xlIPT1FRcA)

guide/russian/algorithms/search-algorithms/exponential-search/index.md

@@ -0,0 +1,95 @@
+---
+title: Exponential Search
+localeTitle: Экспоненциальный поиск
+---
+## Экспоненциальный поиск
+
+Экспоненциальный поиск также известен как поиск пальцем, поиск элемента в отсортированном массиве путем прыжка `2^i` элементов на каждой итерации, где i представляет значение переменной управления циклом, а затем проверку наличия элемента поиска между последним прыжком и текущим прыжком
+
+# Сложность Худший случай
+
+O (журнал (N)) Часто путают из-за имени, алгоритм называется так не из-за временной сложности. Имя возникает из-за алгоритма, прыгающего с шагами, равными показателям 2
+
+# Работает
+
+1.  `Array[2^(i-1)] < valueWanted < Array[2^i]` элементы массива `2^i` за раз, ища условие. `Array[2^(i-1)] < valueWanted < Array[2^i]` . Если `2^i` больше длины массива, установите верхнюю границу длины массива.
+2.  Сделайте двоичный поиск между `Array[2^(i-1)]` и `Array[2^i]`
+
+# Код
+```
+// C++ program to find an element x in a 
+ // sorted array using Exponential search. 
+ #include <bits/stdc++.h> 
+ using namespace std; 
+ 
+ int binarySearch(int arr[], int, int, int); 
+ 
+ // Returns position of first ocurrence of 
+ // x in array 
+ int exponentialSearch(int arr[], int n, int x) 
+ { 
+    // If x is present at firt location itself 
+    if (arr[0] == x) 
+        return 0; 
+ 
+    // Find range for binary search by 
+    // repeated doubling 
+    int i = 1; 
+    while (i < n && arr[i] <= x) 
+        i = i*2; 
+ 
+    //  Call binary search for the found range. 
+    return binarySearch(arr, i/2, min(i, n), x); 
+ } 
+ 
+ // A recursive binary search function. It returns 
+ // location of x in  given array arr[l..r] is 
+ // present, otherwise -1 
+ int binarySearch(int arr[], int l, int r, int x) 
+ { 
+    if (r >= l) 
+    { 
+        int mid = l + (r - l)/2; 
+ 
+        // If the element is present at the middle 
+        // itself 
+        if (arr[mid] == x) 
+            return mid; 
+ 
+        // If element is smaller than mid, then it 
+        // can only be present n left subarray 
+        if (arr[mid] > x) 
+            return binarySearch(arr, l, mid-1, x); 
+ 
+        // Else the element can only be present 
+        // in right subarray 
+        return binarySearch(arr, mid+1, r, x); 
+    } 
+ 
+    // We reach here when element is not present 
+    // in array 
+    return -1; 
+ } 
+ 
+ int main(void) 
+ { 
+   int arr[] = {2, 3, 4, 10, 40}; 
+   int n = sizeof(arr)/ sizeof(arr[0]); 
+   int x = 10; 
+   int result = exponentialSearch(arr, n, x); 
+   (result == -1)? printf("Element is not present in array") 
+                 : printf("Element is present at index %d", result); 
+   return 0; 
+ } 
+```
+
+# Больше информации
+
+*   [Википедия](https://en.wikipedia.org/wiki/Exponential_search)
+    
+*   [GeeksForGeeks](https://www.geeksforgeeks.org/exponential-search/)
+    
+
+# кредиты
+
+[Реализация C ++](https://www.wikitechy.com/technology/exponential-search/)

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

@@ -0,0 +1,21 @@
+---
+title: Search Algorithms
+localeTitle: Алгоритмы поиска
+---
+## Алгоритмы поиска
+
+В информатике алгоритмом поиска является любой алгоритм, который решает проблему поиска, а именно: извлекать информацию, хранящуюся в некоторой структуре данных, или рассчитывать в пространстве поиска проблемного домена. Примеры таких структур включают связанные списки, массивы данных данных, деревья поиска и многое другое. Соответствующий алгоритм поиска часто зависит от поиска данных, но также от предварительного знания данных. [Подробнее о википедии](https://en.wikipedia.org/wiki/Search_algorithm) .
+
+Этот алгоритм рассматривает проблему переустановки массива элементов в порядке ввода. Два наиболее общих примера этого - бинарный поиск и алгоритм сортировки слияния.
+
+В следующих ссылках вы также можете найти дополнительную информацию о:
+
+*   Двоичный поиск
+*   Линейный поиск
+*   Поиск связанных списков против массивов
+
+#### Дополнительная информация:
+
+*   MIT OCW Введение в алгоритмы [поиска](https://ocw.mit.edu/courses/electrical-engineering-and-computer-science/6-01sc-introduction-to-electrical-engineering-and-computer-science-i-spring-2011/unit-4-probability-and-planning/search-algorithms/) .
+*   Принстонский университет: [сортировка и поиск.](https://introcs.cs.princeton.edu/java/42sort/)
+*   Анатомия поисковой системы [(Google).](http://infolab.stanford.edu/~backrub/google.html)

guide/russian/algorithms/search-algorithms/jump-search/index.md

@@ -0,0 +1,29 @@
+---
+title: Jump Search
+localeTitle: Перейти к поиску
+---
+## Перейти к поиску
+
+Поиск по скачкам обнаруживает элемент в отсортированном массиве, перескакивая k itens и затем проверяя, нужен ли элемент между предыдущий прыжок и текущий прыжок.
+
+# Сложность Худший случай
+
+O (√N)
+
+# Работает
+
+1.  Определите значение k, число прыжков: оптимальный размер перехода - √N, где N - длина массива
+2.  Перейдите в массив k-by-k, `Array[i] < valueWanted < Array[i+k]` поиск по условию `Array[i] < valueWanted < Array[i+k]`
+3.  Сделайте линейный поиск между `Array[i]` и `Array[i + k]`
+
+![Прыжки с поиском 1](https://i1.wp.com/theoryofprogramming.com/wp-content/uploads/2016/11/jump-search-1.jpg?resize=676%2C290)
+
+# Код
+
+Чтобы просмотреть примеры реализации кода этого метода, перейдите по этой ссылке ниже:
+
+[Поиск по прыжкам - OpenGenus / космос](https://github.com/OpenGenus/cosmos/tree/master/code/search/jump_search)
+
+# кредиты
+
+[Изображение массива логики](http://theoryofprogramming.com/2016/11/10/jump-search-algorithm/)

guide/russian/algorithms/search-algorithms/linear-search/index.md

@@ -0,0 +1,140 @@
+---
+title: Linear Search
+localeTitle: Линейный поиск
+---
+## Линейный поиск
+
+Предположим, вам предоставлен список или массив элементов. Вы ищете определенный предмет. Как ты это делаешь?
+
+Найдите номер 13 в данном списке.
+
+![Линейный поиск 1](https://i.imgur.com/ThkzYEV.jpg)
+
+Вы просто смотрите на список, и вот он!
+
+![Линейный поиск 2](https://i.imgur.com/K7HfCly.jpg)
+
+Теперь, как вы говорите компьютеру, чтобы его найти.
+
+Компьютер не может смотреть больше, чем значение в данный момент времени. Поэтому он берет один элемент из массива и проверяет, совпадает ли он с тем, что вы ищете.
+
+![Линейный поиск 3](https://i.imgur.com/ZOSxeZD.jpg)
+
+Первый элемент не совпал. Поэтому переходите к следующему.
+
+![Линейный поиск 4](https://i.imgur.com/SwKsPxD.jpg)
+
+И так далее…
+
+Это делается до тех пор, пока не будет найдено совпадение или пока все элементы не будут проверены.
+
+![Линейный поиск 5](https://i.imgur.com/3AaViff.jpg)
+
+В этом алгоритме вы можете остановиться, когда элемент найден, и тогда нет необходимости смотреть дальше.
+
+Итак, сколько времени потребуется на операцию линейного поиска? В лучшем случае вам может повезти, и предмет, на который вы смотрите, может быть, на первой позиции в массиве! Но в худшем случае вам придется смотреть на каждый элемент, прежде чем вы найдете элемент на последнем месте или до того, как осознаете, что элемент не находится в массиве.
+
+Поэтому сложность линейного поиска заключается в следующем: O (n).
+
+Если элемент, подлежащий поиску, возглавляет первый блок памяти, тогда сложность будет: O (1).
+
+Код для функции линейного поиска в JavaScript показан ниже. Эта функция возвращает позицию элемента, который мы ищем в массиве. Если элемент отсутствует в массиве, функция возвращает null.
+
+### Пример в Javascript
+
+```javascript
+function linearSearch(arr, item) { 
+  // Go through all the elements of arr to look for item. 
+  for (var i = 0; i < arr.length; i++) { 
+    if (arr[i] === item) { // Found it! 
+      return i; 
+    } 
+  } 
+ 
+  // Item not found in the array. 
+  return null; 
+ } 
+```
+
+### Пример в Ruby
+
+```ruby
+def linear_search(target, array) 
+  counter = 0 
+ 
+  while counter < array.length 
+    if array[counter] == target 
+      return counter 
+    else 
+      counter += 1 
+    end 
+  end 
+  return nil 
+ end 
+```
+
+### Пример в C ++
+
+```c++
+int linear_search(int arr[],int n,int num) 
+ { 
+    for(int i=0;i<n;i++){ 
+        if(arr[i]==num) 
+            return i; 
+   } 
+   // Item not found in the array 
+   return -1; 
+ } 
+```
+
+### Пример в Python
+
+```python
+def linear_search(array, num): 
+    for i in range(len(array)): 
+        if (array[i]==num): 
+            return i 
+    return -1 
+```
+
+## Глобальный линейный поиск
+
+Что делать, если вы ищете несколько вхождений элемента? Например, вы хотите увидеть, сколько 5 в массиве.
+
+Цель = 5
+
+Массив = \[1, 2, 3, 4, 5, 6, 5, 7, 8, 9, 5\]
+
+Этот массив имеет 3 входа 5s, и мы хотим вернуть индексы (где они находятся в массиве) всех из них. Это называется глобальным линейным поиском, и вам нужно будет настроить свой код, чтобы вернуть массив указательных точек, в которых он обнаруживает целевой элемент. Когда вы найдете элемент индекса, который соответствует вашей цели, в массиве результатов будет добавлена ​​точка-указатель (счетчик). Если он не соответствует коду, он продолжит движение к следующему элементу массива, добавив 1 к счетчику.
+
+```ruby
+def global_linear_search(target, array) 
+  counter = 0 
+  results = [] 
+ 
+  while counter < array.length 
+    if array[counter] == target 
+      results << counter 
+      counter += 1 
+    else 
+      counter += 1 
+    end 
+  end 
+ 
+  if results.empty? 
+    return nil 
+  else 
+    return results 
+  end 
+ end 
+```
+
+## Почему линейный поиск неэффективен
+
+Нет никаких сомнений в том, что линейный поиск прост, но поскольку он сравнивает каждый элемент один за другим, он занимает много времени и, следовательно, не очень эффективен. Если нам нужно найти число, скажем, 1000000 номеров и номеров находится в последнем месте, техника линейного поиска станет довольно утомительной. Итак, также узнайте о сортировке пузырьков, быстрой сортировке и т. Д.
+
+#### Соответствующее видео:
+
+#### Другие источники
+
+[Линейный поиск - CS50](https://www.youtube.com/watch?v=vZWfKBdSgXI)

guide/russian/algorithms/search-algorithms/searching-linked-lists-versus-arrays/index.md

@@ -0,0 +1,23 @@
+---
+title: Searching Linked Lists Versus Arrays
+localeTitle: Поиск связанных списков в сравнении с массивами
+---
+## Поиск связанных списков в сравнении с массивами
+
+Предположим, вам нужно искать элемент в _несортированном_ связанном списке и массиве. В этом случае вам необходимо выполнить линейный поиск (помните, unsorted). Выполнение линейного поиска элемента в любой структуре данных будет выполнять операцию O (n).
+
+Теперь, если у вас есть _отсортированный_ связанный список и массив, вы можете искать в обеих структурах данных в O (log n) время с помощью Binary Search. Хотя, будет немного утомительно кодировать при использовании связанных списков.
+
+Связанные списки обычно предпочтительны для массивов, где вставка является частой операцией. Его легче вставлять в связанные списки, поскольку изменяется только указатель. Но чтобы вставить в массив (средний или начальный), вам нужно переместить все элементы после того, который вы вставляете. Другое место, где вы должны использовать связанные списки, - это размер неопределенности (вы не знаете размер, когда вы начинаете), потому что массивы имеют фиксированный размер.
+
+Массивы предоставляют несколько преимуществ по сравнению с связанными списками:
+
+1.  Случайный доступ
+2.  Меньше памяти по сравнению со связанными списками
+3.  Массивы имеют лучшую локальность кэша, что обеспечивает лучшую производительность
+
+Это полностью зависит от варианта использования для того, лучше ли массивы или связанные списки.
+
+### Дополнительная информация:
+
+*   Подход программиста к взгляду на связанный список против массива: [выродки для вундеркиндов](http://www.geeksforgeeks.org/programmers-approach-looking-array-vs-linked-list/)