fix(guide): simplify directory structure

guide/chinese/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 
+```
+
+这意味着您可以将日志分为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）搜索时间而非常强大，其次是使用哈希键数据结构来搜索O（1）中的数据。了解log n运行时如何来自二叉搜索树的高度非常重要。如果每个节点分成两个节点（二进制），则树的深度为log n（基数2）。为了提高数据系统中的速度，我们使用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（结束> =开始） { 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); 
+```
+
+} 返回-1; }
+```
+Iterative approach! 
+```
+
+C ++ - 迭代方法 int binarySearch（int arr \[\]，int start，int end，int x） { while（开始<=结束） { int mid = start +（end - start）/ 2; if（arr \[mid\] == x） 返回中间; if（arr \[mid\] <x） start = mid + 1; 其他 结束=中 - 1; } 返回-1; } \`\`\`
+
+### 更多信息
+
+*   [二进制搜索（YouTube视频）](https://youtu.be/P3YID7liBug)
+*   [二进制搜索 - CS50](https://www.youtube.com/watch?v=5xlIPT1FRcA)

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

@@ -0,0 +1,95 @@
+---
+title: Exponential Search
+localeTitle: 指数搜索
+---
+## 指数搜索
+
+指数搜索也称为手指搜索，通过每次迭代跳过`2^i`元素来搜索排序数组中的元素，其中i表示 循环控制变量的值，然后验证在最后一次跳转和当前跳转之间是否存在搜索元素
+
+# 复杂性最坏的情况
+
+为O（log（N）） 由于名称经常混淆，因此算法的命名不是因为时间复杂性。 该名称是由于算法跳过具有等于2的指数的步骤的元素而产生的
+
+# 作品
+
+1.  一次跳转数组`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/chinese/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)的解剖结构[。](http://infolab.stanford.edu/~backrub/google.html)

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

@@ -0,0 +1,29 @@
+---
+title: Jump Search
+localeTitle: 跳转搜索
+---
+## 跳转搜索
+
+跳转搜索通过跳跃k itens定位已排序数组中的项目，然后验证项目是否在中间 先前的跳跃和当前跳跃。
+
+# 复杂性最坏的情况
+
+O（√N）
+
+# 作品
+
+1.  定义k的值，跳跃的数量：最佳跳跃大小为√N，其中N是数组的长度
+2.  按条件`Array[i] < valueWanted < Array[i+k]`跳转数组k-by-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 / cosmos](https://github.com/OpenGenus/cosmos/tree/master/code/search/jump_search)
+
+# 积分
+
+[逻辑的阵列图像](http://theoryofprogramming.com/2016/11/10/jump-search-algorithm/)

guide/chinese/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/chinese/algorithms/search-algorithms/searching-linked-lists-versus-arrays/index.md

@@ -0,0 +1,23 @@
+---
+title: Searching Linked Lists Versus Arrays
+localeTitle: 搜索链接列表与阵列
+---
+## 搜索链接列表与阵列
+
+假设您必须在_未排序的_链表和数组中搜索元素。在这种情况下，您需要进行线性搜索（记住，未排序）。对数据结构中的元素进行线性搜索将是O（n）操作。
+
+现在，如果您有一个已_排序的_链表和数组，您仍然可以使用二进制搜索在O（log n）时间内搜索这两个数据结构。虽然，使用链表时编码会有点繁琐。
+
+链接列表通常比插入频繁操作的数组更受欢迎。由于只有指针发生变化，因此在链表中插入更容易。但要插入数组（中间或开头），您需要移动所插入的元素之后的所有元素。您应该使用链接列表的另一个地方是大小不确定（您在开始时不知道大小），因为数组具有固定大小。
+
+与链表相比，数组确实提供了一些优势：
+
+1.  随机访问
+2.  与链表相比，内存更少
+3.  数组具有更好的缓存局部性，从而提供更好的性能
+
+它完全取决于数组或链表是否更好的用例。
+
+### 更多信息：
+
+*   程序员查看链表和数组的方法： [极客的极客](http://www.geeksforgeeks.org/programmers-approach-looking-array-vs-linked-list/)