2020-07-05 16:23:01

docs/array/10.md

@@ -2,9 +2,9 @@
 
 > 原文： [https://www.geeksforgeeks.org/program-for-array-rotation-continued-reversal-algorithm/](https://www.geeksforgeeks.org/program-for-array-rotation-continued-reversal-algorithm/)
 
-编写一个函数 turn（arr []，d，n），该函数将大小为 n 的 arr []旋转 d 个元素。
+编写一个函数`turn(arr[], d, n)`，该函数将大小为`n`的`arr[]`旋转`d`个元素。
 
-**范例**：
+**示例**：
 
 ```
 Input :  arr[] = [1, 2, 3, 4, 5, 6, 7]
@@ -21,8 +21,9 @@ Output : arr[] = [3, 4, 5, 6, 7, 1, 2]
 
 ## [推荐：请先在“ ***<u>实践</u>*** ”上解决它，然后再继续解决。](https://practice.geeksforgeeks.org/problems/reversal-algorithm/0)
 
-在的[中讨论了通过 d 个元素旋转数组的前 3 种方法。
-**方法 4（反向算法）**：](https://www.geeksforgeeks.org/array-rotation/)
+在[这里](https://www.geeksforgeeks.org/array-rotation/)中讨论了通过`d`个元素旋转数组的前 3 种方法。
+
+**方法 4（反向算法）**：
 
 **算法**：
 
@@ -34,20 +35,20 @@ rotate(arr[], d, n)
 
 ```
 
-令 AB 为输入数组的两个部分，其中 A = arr [0..d-1]和 B = arr [d..n-1]。 该算法的思想是：
+令`AB`为输入数组的两个部分，其中`A = arr[0..d-1]`和`B = arr[d..n-1]`。 该算法的思想是：
 
-*   反转 A 以获得 ArB，其中 Ar 反转 A。
-*   颠倒 B 以获得 ArBr，其中 Br 颠倒 B.
-*   取反得到（ArBr）r = BA。
+*   反转`A`以获得`ArB`，其中`Ar`反转`A`。
+*   反转`B`以获得`ArBr`，其中`Br`反转`B`.
+*   取反得到`(ArBr)r = BA`。
 
 **示例**：
-令数组为 arr [] = [1、2、3、4、5、6、7]，d = 2 和 n = 7
-A = [1， 2]和 B = [3，4，5，6，7]
-
-*   反向 A，我们得到 ArB = [2、1、3、4、5、6、7]
-*   反向 B，我们得到 ArBr = [2，1，7，6，6，5，4，3]
-*   颠倒所有，我们得到（ArBr）r = [3，4，5，6，6，7，1，2]
+令数组为 `arr[] = [1, 2, 3, 4, 5, 6, 7]`，`d = 2`和`n = 7`
+`A = [1, 2]`和`B = [3, 4, 5, 6, 7]`
 
+*   反向`A`，我们得到`ArB = [2, 1, 3, 4, 5, 6, 7]`
+*   反向`B`，我们得到`ArBr = [2, 1, 7, 6, 6, 5, 4, 3]`
+*   反向所有，我们得到`(ArBr)r = [3, 4, 5, 6, 6, 7, 1, 2]`
+`
 下面是上述方法的实现：
 
 ## C++ 

docs/array/101.md

@@ -225,7 +225,7 @@ generated is 10 10 10 15 15 90 90
 
     ```
 
-    ## 的 PHP
+    ## PHP
 
     ```
 

docs/array/102.md

@@ -257,7 +257,7 @@ index 6, so the distance is 1
 
     ```
 
-    ## 的 PHP
+    ## PHP
 
     ```
 

docs/array/103.md

@@ -3,7 +3,7 @@
 > 原文： [https://www.geeksforgeeks.org/find-the-maximum-element-in-an-array-which-is-first-increasing-and-then-decreasing/](https://www.geeksforgeeks.org/find-the-maximum-element-in-an-array-which-is-first-increasing-and-then-decreasing/)
 
 给定一个整数数组，该数组最初是递增的，然后递减的，请在该数组中找到最大值。
-**范例**：
+**示例**：
 
 ```
 Input: arr[] = {8, 10, 20, 80, 100, 200, 400, 500, 3, 2, 1}

docs/array/105.md

@@ -181,7 +181,7 @@ Here is a proverb, “*Tell me and I will forget. Show me and I will remember. I
 
 *最初的内容准备工作大约花了我 6 个小时。 但是，这是一个很好的教训。 我在一个小时内完成了初始代码。 当我开始写内容向读者解释时，我意识到我不理解这些案例。 拿了我的笔记本（我习惯于装订绑定的笔记本以跟踪我的粗略工作），几个小时后，我填写了将近 15 页的粗略工作。 无论您在灰色示例中看到的内容是来自这些页面的。 我强烈建议您实践《 Udi Manber 算法入门》一书中的注释触发解决方案的所有思考过程。*
 
-我怀疑，许多读者可能无法理解 CeilIndex（二进制搜索）背后的逻辑。 我把它作为练习让读者理解它是如何工作的。 在纸上浏览几个示例。 我意识到我已经在[的另一篇文章](https://www.geeksforgeeks.org/the-ubiquitous-binary-search-set-1/)中介绍了该算法。
+我怀疑，许多读者可能无法理解 CeilIndex（二分搜索）背后的逻辑。 我把它作为练习让读者理解它是如何工作的。 在纸上浏览几个示例。 我意识到我已经在[的另一篇文章](https://www.geeksforgeeks.org/the-ubiquitous-binary-search-set-1/)中介绍了该算法。
 
 **更新– 2016 年 8 月 5 日**：
 
@@ -470,7 +470,7 @@ class GFG {
 
 ```
 
-## 的 PHP
+## PHP
 
 ```
 
@@ -553,7 +553,7 @@ Length of Longest Increasing Subsequence is 6
 
 **复杂度**：
 
-循环运行 N 个元素。 在最坏的情况下（什么是最坏情况的输入？），我们最终可能会使用二进制搜索（log *i* ）来查询许多 A [i]的 ceil 值。
+循环运行 N 个元素。 在最坏的情况下（什么是最坏情况的输入？），我们最终可能会使用二分搜索（log *i* ）来查询许多 A [i]的 ceil 值。
 
 因此，T（n）< O（log N！）= O（N log N）。 分析以确保上限和下限也是 O（N log N）。 复杂度为 THETA（N log N）。
 

docs/array/109.md

@@ -26,7 +26,7 @@ Output: 5 8 9
 
 **简单方法**是使用嵌套循环。 外循环按顺序遍历每个元素。 在外部循环内，运行两个内部循环（一个接一个）以查找当前元素的 LSL 和 LGR。 该方法的时间复杂度为 O（n <sup>2</sup> ）。
 
-我们可以在 O（nLogn）时间中执行**。 为简单起见，让我们首先创建两个大小为 n 的数组 LSL []和 LGR []，其中 n 是输入数组 arr []中的元素数。 主要任务是填充两个数组 LSL []和 LGR []。 一旦我们填充了这两个数组，我们就需要找到最大乘积 LSL [i] * arr [i] * LGR [i]，其中 0 < i < n-1（请注意 LSL [i]不会 i = 0 时 t 存在，而 i = n-1 时 LGR [i]不存在。 我们可以在 O（nLogn）时间中填写 **LSL []** 。 这个想法是使用像 AVL 这样的平衡二进制搜索树。 我们从空的 AVL 树开始，在其中插入最左边的元素。 然后，我们从第二个元素开始到倒数第二个元素遍历输入数组。 对于当前正在遍历的每个元素，我们在 AVL 树中找到它的底面。 如果存在楼层，则将楼层存储在 LSL []中，否则将存储 NIL。 存储地板后，我们将当前元素插入 AVL 树中。**
+我们可以在 O（nLogn）时间中执行**。 为简单起见，让我们首先创建两个大小为 n 的数组 LSL []和 LGR []，其中 n 是输入数组 arr []中的元素数。 主要任务是填充两个数组 LSL []和 LGR []。 一旦我们填充了这两个数组，我们就需要找到最大乘积 LSL [i] * arr [i] * LGR [i]，其中 0 < i < n-1（请注意 LSL [i]不会 i = 0 时 t 存在，而 i = n-1 时 LGR [i]不存在。 我们可以在 O（nLogn）时间中填写 **LSL []** 。 这个想法是使用像 AVL 这样的平衡二分搜索树。 我们从空的 AVL 树开始，在其中插入最左边的元素。 然后，我们从第二个元素开始到倒数第二个元素遍历输入数组。 对于当前正在遍历的每个元素，我们在 AVL 树中找到它的底面。 如果存在楼层，则将楼层存储在 LSL []中，否则将存储 NIL。 存储地板后，我们将当前元素插入 AVL 树中。**
 
 我们可以在 O（n）时间中将**填充 LGR []** 。 这个想法类似于这个帖子的[。 我们从右侧遍历并跟踪最大元素。 如果最大元素大于当前元素，则将其存储在 LGR []中，否则将存储 NIL。](https://www.geeksforgeeks.org/replace-every-element-with-the-greatest-on-right-side/)
 

docs/array/11.md

@@ -2,7 +2,7 @@
 
 > 原文： [https://www.geeksforgeeks.org/block-swap-algorithm-for-array-rotation/](https://www.geeksforgeeks.org/block-swap-algorithm-for-array-rotation/)
 
-编写一个函数 turn（ar []，d，n），该函数将大小为 n 的 arr []旋转 d 个元素。
+编写一个函数`turn(ar[], d, n)`，该函数将大小为`n`的`arr[]`旋转`d`个元素。
 
 ![Array](img/ba17844d7fa31a1b00169a41fc3bc3d3.png "Array")
 

docs/array/119.md

@@ -29,7 +29,7 @@ Output:    {_,   _, 10, 11, 20, 40, 50,  50, ...}
 如何处理 流的新元素？
 对于流中的每个新元素，请检查新元素是否小于当前的第 k 个最大元素。 如果是，则忽略它。 如果否，则从数组中删除最小的元素，并按排序顺序插入新元素。 处理新元素的时间复杂度为 O（k）。
 
-**更好的解决方案**是使用大小为 k 的自平衡二进制搜索树。 可以在 O（Logk）时间中找到第 k 个最大元素。
+**更好的解决方案**是使用大小为 k 的自平衡二分搜索树。 可以在 O（Logk）时间中找到第 k 个最大元素。
 如何处理流的新元素？
 对于流中的每个新元素，请检查新元素是否小于当前的第 k 个最大元素。 如果是，则忽略它。 如果否，则从树中删除最小的元素并插入新元素。 处理新元素的时间复杂度为 O（Logk）。
 

docs/array/12.md

@@ -15,9 +15,9 @@ Output: arr[] = {5, 1, 2, 3, 4}
 ## [推荐：请先在“ ***<u>实践</u>*** ”上解决它，然后再继续解决。](https://practice.geeksforgeeks.org/problems/cyclically-rotate-an-array-by-one/0)
 
 以下是步骤。
-1）将最后一个元素存储在变量 x 中。
+1）将最后一个元素存储在变量`x`中。
 2）将所有元素向前移动一个位置。
-3）将数组的第一个元素替换为 x。
+3）将数组的第一个元素替换为`x`。
 
 ## C++ 
 
@@ -204,7 +204,7 @@ public class Test
 
 ```
 
-## 的 PHP
+## PHP
 
 ```
 
@@ -251,8 +251,8 @@ Rotated array is
 5 1 2 3 4
 ```
 
-时间复杂度：O（n）当我们需要遍历所有元素时
-辅助空间：O（1）
+时间复杂度：`O(n)`当我们需要遍历所有元素时
+辅助空间：`O(1)`
 
 通过使用[逆转算法](https://www.geeksforgeeks.org/program-for-array-rotation-continued-reversal-algorithm/)也可以解决上述问题
 

docs/array/121.md

@@ -277,7 +277,7 @@ public class GFG {
 
 ```
 
-## 的 PHP
+## PHP
 
 ```
 

docs/array/122.md

@@ -188,7 +188,7 @@ public static void Main(String[] args)
 
 ```
 
-## 的 PHP
+## PHP
 
 ```
 

docs/array/123.md

@@ -227,7 +227,7 @@ class GFG
 
 ```
 
-## 的 PHP
+## PHP
 
 ```
 

docs/array/13.md

@@ -2,7 +2,7 @@
 
 > 原文： [https://www.geeksforgeeks.org/search-an-element-in-a-sorted-and-pivoted-array/](https://www.geeksforgeeks.org/search-an-element-in-a-sorted-and-pivoted-array/)
 
-通过[二进制搜索](https://www.geeksforgeeks.org/binary-search/)可以在 O（log n）时间找到排序数组中的元素。 但是，假设我们在您事先不知道的某个枢轴处旋转一个升序排序的数组。 因此，例如 1 2 3 4 5 可能变成 3 4 5 1 2。设计一种在 O（log n）时间内在旋转数组中查找元素的方法。
+通过[二分搜索](https://www.geeksforgeeks.org/binary-search/)可以在`O(log n)`时间找到排序数组中的元素。 但是，假设我们在您事先不知道的某个枢轴处旋转一个升序排序的数组。 因此，例如`1 2 3 4 5`可能变成`3 4 5 1 2`。设计一种在`O(log n)`时间内在旋转数组中查找元素的方法。
 
 ![sortedPivotedArray](img/c522cf12d6b34447ea37b38f556b4bfe.png "sortedPivotedArray")
 
@@ -25,9 +25,9 @@ Output : Found at index 3
 
 **此处提供的所有解决方案均假定数组中的所有元素都是不同的。**
 
-这个想法是找到枢轴点，将数组分为两个子数组，然后调用二进制搜索。
+这个想法是找到枢轴点，将数组分为两个子数组，然后调用二分搜索。
 查找枢轴的主要思想是–对于排序（按递增顺序）和枢轴化的数组，枢轴元素是唯一一个其下一个元素小于它的元素。
-使用上述标准和二进制搜索方法，我们可以在 O（logn）时间中获取枢轴元素
+使用上述标准和二分搜索方法，我们可以在`O(logn)`时间中获取枢轴元素
 
 ```
 Input arr[] = {3, 4, 5, 1, 2}

docs/array/134.md

@@ -342,7 +342,7 @@ public static void Main()
 
 ```
 
-## 的 PHP
+## PHP
 
 ```
 

docs/array/137.md

@@ -189,7 +189,7 @@ class GFG  {
 
 ```
 
-## 的 PHP
+## PHP
 
 ```
 
@@ -243,7 +243,7 @@ function countInRange($arr, $n,
 
 ```
 
-**有效方法**将是首先对数组进行排序，然后使用经过修改的二进制搜索函数找到两个索引，第一个元素大于或等于范围下限，另一个元素小于 或等于上限。 运行每个查询的时间为 O（logn），对数组进行一次排序的时间为 O（nlogn）。
+**有效方法**将是首先对数组进行排序，然后使用经过修改的二分搜索函数找到两个索引，第一个元素大于或等于范围下限，另一个元素小于 或等于上限。 运行每个查询的时间为 O（logn），对数组进行一次排序的时间为 O（nlogn）。
 
 ## C++
 

docs/array/138.md

@@ -230,7 +230,7 @@ class GFG {
 
 ```
 
-## 的 PHP
+## PHP
 
 ```
 

docs/array/14.md

@@ -2,7 +2,7 @@
 
 > 原文： [https://www.geeksforgeeks.org/given-a-sorted-and-rotated-array-find-if-there-is-a-pair-with-a-given-sum/](https://www.geeksforgeeks.org/given-a-sorted-and-rotated-array-find-if-there-is-a-pair-with-a-given-sum/)
 
-给定一个已排序的数组，然后围绕未知点旋转。 查找数组是否具有给定总和为“ x”的对。 可以假定数组中的所有元素都是不同的。
+给定一个已排序的数组，然后围绕未知点旋转。 查找数组是否具有给定总和为“`x`”的对。 可以假定数组中的所有元素都是不同的。
 
 **示例**：
 
@@ -23,7 +23,7 @@ There is no pair with sum 45.
 
 ## [推荐：在继续解决之前，请先在 ***<u>{IDE}</u>*** 上尝试您的方法。](https://ide.geeksforgeeks.org/)
 
-我们已经讨论了用于排序数组的 [O（n）解（请参见方法 1 的步骤 2、3 和 4）](https://www.geeksforgeeks.org/write-a-c-program-that-given-a-set-a-of-n-numbers-and-another-number-x-determines-whether-or-not-there-exist-two-elements-in-s-whose-sum-is-exactly-x/)。 我们也可以将此解决方案扩展到旋转数组。 这个想法是首先找到数组中最大的元素，它也是枢轴点，紧随其后的元素是最小的元素。 一旦我们有了最大和最小元素的索引，就可以在中间算法（如方法 1 中的[此处讨论的）中使用类似的 Meet 来查找是否存在一对。 唯一的新变化是使用模块化算法以循环方式递增和递减索引。](https://www.geeksforgeeks.org/write-a-c-program-that-given-a-set-a-of-n-numbers-and-another-number-x-determines-whether-or-not-there-exist-two-elements-in-s-whose-sum-is-exactly-x/)
+我们已经讨论了用于排序数组的[`O(n)`解（请参见方法 1 的步骤 2、3 和 4）](https://www.geeksforgeeks.org/write-a-c-program-that-given-a-set-a-of-n-numbers-and-another-number-x-determines-whether-or-not-there-exist-two-elements-in-s-whose-sum-is-exactly-x/)。 我们也可以将此解决方案扩展到旋转数组。 这个想法是首先找到数组中最大的元素，它也是枢轴点，紧随其后的元素是最小的元素。 一旦我们有了最大和最小元素的索引，就可以在中间算法（如方法 1 中的[此处](https://www.geeksforgeeks.org/write-a-c-program-that-given-a-set-a-of-n-numbers-and-another-number-x-determines-whether-or-not-there-exist-two-elements-in-s-whose-sum-is-exactly-x/)讨论的）中使用类似的 Meet 来查找是否存在一对。 唯一的新变化是使用模块化算法以循环方式递增和递减索引。
 
 以下是上述想法的实现。
 

docs/array/140.md

@@ -4,7 +4,7 @@
 
 系统会为您提供 N 个整数和 Q 个查询的序列。 在每个查询中，给您两个参数 L 和 R。您必须找到最小的整数 X，使得 0 < = X < 2 ^ 31，并且 x 与所有元素的 XOR 之和为范围[L， R]是最大可能的。
 
- **范例**：
+ **示例**：
 
 ```
 Input  : A = {20, 11, 18, 2, 13}
@@ -391,7 +391,7 @@ class GFG{
 
 ```
 
-## 的 PHP
+## PHP
 
 ```
 

docs/array/147.md

@@ -40,7 +40,7 @@ smallest number in the range
 
 在此之后，我们将建立一个合并排序树，其中每个节点都有一个在排序范围内的索引向量。
 
-当我们必须回答一个查询时，我们发现第 K 个<sup>最小的</sup>数目是在左子树中还是在右子树中。 想法是使用两个二进制搜索并找到左侧子树中的元素数量，以使索引位于给定的查询范围内。
+当我们必须回答一个查询时，我们发现第 K 个<sup>最小的</sup>数目是在左子树中还是在右子树中。 想法是使用两个二分搜索并找到左侧子树中的元素数量，以使索引位于给定的查询范围内。
 令此类索引的数量为 M。
 
 如果 M > = K，则意味着我们将能够在左侧子树中找到第 K 个<sup>最小的</sup>编号，因此我们在左侧子树中进行调用。

docs/array/148.md

@@ -302,7 +302,7 @@ public static void Main(String[] args)
 
 ```
 
-## 的 PHP
+## PHP
 
 ```
 

docs/array/15.md

-# 在只允许旋转给定数组的情况下找到 Sum（i * arr [i]）的最大值
+# 在只允许旋转给定数组的情况下找到`Sum(i * arr[i])`的最大值
 
 > 原文： [https://www.geeksforgeeks.org/find-maximum-value-of-sum-iarri-with-only-rotations-on-given-array-allowed/](https://www.geeksforgeeks.org/find-maximum-value-of-sum-iarri-with-only-rotations-on-given-array-allowed/)
 
-给定一个数组，仅允许对数组进行旋转操作。 我们可以根据需要旋转数组多次。 返回 i * arr [i]的总和的最大可能性。
+给定一个数组，仅允许对数组进行旋转操作。 我们可以根据需要旋转数组多次。 返回`i * arr[i]`的总和的最大可能性。
 
 **示例**：
 
@@ -23,13 +23,13 @@ We can 330 by rotating array 9 times.
 
 **我们强烈建议您最小化浏览器，然后自己尝试。**
 
-一个**简单解决方案**是一个个地查找所有旋转，检查每个旋转的总和并返回最大和。 该解决方案的时间复杂度为 O（n <sup>2</sup> ）。
+一个**简单解决方案**是一个个地查找所有旋转，检查每个旋转的总和并返回最大和。 该解决方案的时间复杂度为`O(n^2)`。
 
-我们可以使用**有效解决方案**在 O（n）时间内解决此问题。
-令 R <sub>j</sub> 为 i * arr [i]旋转 j 的值。 该想法是根据先前旋转来计算下一旋转值，即，根据 R <sub>j-1</sub> 计算 R <sub>j</sub> 。 我们可以将结果的初始值计算为 R <sub>0</sub> ，然后继续计算下一个旋转值。
+我们可以使用**有效解决方案**在`O(n)`时间内解决此问题。
+令`R[j]`为`i * arr[i]`旋转`j`的值。 该想法是根据先前旋转来计算下一旋转值，即，根据`R[j-1]`计算`R[j]`。 我们可以将结果的初始值计算为`R[0]`，然后继续计算下一个旋转值。
 
-**如何从 R <sub>j-1</sub> 有效地计算 R <sub>j</sub> ？**
-这可以在 O（1）时间内完成。 以下是详细信息。
+**如何从`R[j-1]`有效地计算`R[j]`？**
+这可以在`O(1)`时间内完成。 以下是详细信息。
 
 ```
 Let us calculate initial value of i*arr[i] with no rotation
@@ -272,7 +272,7 @@ class Test
 
 ```
 
-## 的 PHP
+## PHP
 
 ```
 
@@ -336,8 +336,8 @@ echo "Max sum is " ,
 Max sum is 330
 ```
 
- **时间复杂度**： O（n）
-**辅助空间**： O（1）
+ **时间复杂度**： `O(n)`
+**辅助空间**： `O(1)`
 
 本文由 **Nitesh Singh** 提供。 如果发现任何不正确的地方，或者想分享有关上述主题的更多信息，请发表评论。
 

docs/array/150.md

@@ -307,7 +307,7 @@ class GFG {
 
 ```
 
-## 的 PHP
+## PHP
 
 ```
 

docs/array/151.md

@@ -5,7 +5,7 @@
 给定一个整数数组和一个范围，我们需要查找落入该范围的子数组是否具有山峰形式的值。 如果所有值都是递增或递减的，或者先递增然后递减的，则子数组的所有值都称为山的形式。
 更正式地讲，如果存在整数 K，则称子数组 *[a1，a2，a3…aN]* 为山的形式，因此< = K < = N
 *a1 < = a2 < = a3 .. < = aK > = a（K + 1）> = a（K + 2）…。 > = aN*
-**范例**：
+**示例**：
 
 ```
 Input : Arr[]  = [2 3 2 4 4 6 3 2], Range = [0, 2]

docs/array/158.md

@@ -9,7 +9,7 @@
 
 对于每个查询，打印两个整数 **p** 和 **q** ，它们表示概率 p / q。 p 和 q 都简化为最小形式。
 如果 p 为 0，则打印 0；或者如果 p 等于 q，则打印 1；否则，仅打印 p 和 q。
-**范例**：
+**示例**：
 
 ```
 Input : N = 5, arr[] = { 6, 5, 2, 1, 7 }

docs/array/159.md

@@ -3,7 +3,7 @@
 > 原文： [https://www.geeksforgeeks.org/products-ranges-array/](https://www.geeksforgeeks.org/products-ranges-array/)
 
 给定大小为 N 的数组 A []。解决 Q 个查询。 在模 P 下找到[L，R]范围内的乘积（P 为质数）。
-**范例**：
+**示例**：
 
 ```
 Input : A[] = {1, 2, 3, 4, 5, 6} 

docs/array/16.md

@@ -241,7 +241,7 @@ Explanation: Lets look at all the rotations,
 
     ```
 
-    ## 的 PHP
+    ## PHP
 
     ```
 

docs/array/161.md

@@ -259,7 +259,7 @@ public static void Main()
 
 ```
 
-## 的 PHP
+## PHP
 
 ```
 

docs/array/164.md

@@ -35,7 +35,7 @@ Output : 30
 一个简单的解决方案是运行一个从 l 到 r 的循环，并计算给定范围内的元素之和。 要更新值，请预先计算每个数字的除数的值，然后简单地做 arr [i] = divisors [arr [i]]。
 
 **高效方法**：
-的想法是减少每个查询的时间复杂度，并将操作更新为 O（logN）。 使用二进制索引树（BIT）或段树。 构造一个 BIT []数组，并具有两个用于查询和更新操作的功能，并针对每个数字预先计算除数的数量。 现在，对于每个更新操作，主要观察到的是数字“ 1”和“ 2”的除数分别为“ 1”和“ 2”，因此，如果它存在于更新查询的范围内，则它们不存在。 不需要更新。 我们将使用一个集合来存储仅大于 2 的那些数字的索引，并使用二进制搜索来查找更新查询的 l 索引并递增 l 索引，直到在该更新查询的范围内每个元素都被更新为止。 如果 arr [i]只有 2 个除数，则在更新后将其从集合中删除，因为即使在下一次更新查询之后它也始终为 2。 对于总和查询操作，只需执行 query（r）– query（l – 1）。
+的想法是减少每个查询的时间复杂度，并将操作更新为 O（logN）。 使用二进制索引树（BIT）或段树。 构造一个 BIT []数组，并具有两个用于查询和更新操作的功能，并针对每个数字预先计算除数的数量。 现在，对于每个更新操作，主要观察到的是数字“ 1”和“ 2”的除数分别为“ 1”和“ 2”，因此，如果它存在于更新查询的范围内，则它们不存在。 不需要更新。 我们将使用一个集合来存储仅大于 2 的那些数字的索引，并使用二分搜索来查找更新查询的 l 索引并递增 l 索引，直到在该更新查询的范围内每个元素都被更新为止。 如果 arr [i]只有 2 个除数，则在更新后将其从集合中删除，因为即使在下一次更新查询之后它也始终为 2。 对于总和查询操作，只需执行 query（r）– query（l – 1）。
 
 ```
 

docs/array/172.md

@@ -333,7 +333,7 @@ class GFG {
 
 ```
 
-## 的 PHP
+## PHP
 
 ```
 

docs/array/174.md

@@ -257,7 +257,7 @@ index 6, so the distance is 1
 
     ```
 
-    ## 的 PHP
+    ## PHP
 
     ```
 

docs/array/175.md

@@ -348,7 +348,7 @@ public static void Main()
 
 ```
 
-## 的 PHP
+## PHP
 
 ```
 

docs/array/178.md

@@ -355,7 +355,7 @@ class GFG
 
 ```
 
-## 的 PHP
+## PHP
 
 ```
 

docs/array/179.md

@@ -277,7 +277,7 @@ print("The maximum average subarray of length",k,
 
 ```
 
-## 的 PHP
+## PHP
 
 ```
 

docs/array/18.md

@@ -250,7 +250,7 @@ class LeftRotate
 
 ```
 
-## 的 PHP
+## PHP
 
 ```
 

docs/array/181.md

@@ -25,7 +25,7 @@ that product of elements is less than 1
 **方法**：如果我们通过基本方法来解决此问题，则必须生成所有可能的 2 <sup>n</sup> 子集，然后对于每个子集，我们必须计算子集元素的乘积 并比较给定的产品价值。 但是这种方法的缺点是其时间复杂度太高，即 O（n * 2 <sup>n</sup> ）。 现在，我们可以看到它将是指数时间复杂性，在竞争性编码的情况下应避免这种情况。
 **进阶方法**：我们将在中间使用[开会的概念。](https://www.geeksforgeeks.org/meet-in-the-middle/) 通过使用这个概念，我们可以降低我们求解 O（n * 2 <sup>n / 2</sup> ）的复杂性。
 
-**如何在中间方法中使用 MEET**：首先，我们将给定数组简单地分为两个相等的部分，然后我们为数组的两个部分生成所有可能的子集，并为每个子集存储元素乘积的值 分别分成两个向量（例如，subset1 & subset2）。 现在，这将花费 O（2 <sup>n / 2</sup> ）时间复杂度。 现在，如果我们对这两个向量（子集 1 &子集 2）进行排序，每个向量具有（2 <sup>n / 2</sup> ）个元素，那么这将花费 O（2 <sup>n / 2</sup> * log2 <sup>n / 2</sup> ）≈O（n *（2 <sup>n / 2</sup> ））时间复杂度。 在下一步中，我们遍历一个具有 2 个 <sup>n / 2</sup> 个元素的向量 subset1，并在第二个向量中找到 k / subset1 [i]的上限，这将告诉我们乘积小于 或等于 k。 因此，对于子集 1 中的每个元素，我们将尝试在子集 2 中以 upper_bound 的形式执行二进制搜索，从而再次导致时间复杂度为 O（n *（2 <sup>n / 2</sup> ））。 因此，如果我们尝试计算此方法的总体复杂度，则将有 O（n *（2 <sup>n / 2</sup> ）+ n *（2 <sup>n / 2</sup> ）+ n * （2 <sup>n / 2</sup> ））≈O（n *（2 <sup>n / 2</sup> ））作为我们的时间复杂度，这比蛮力法效率高得多。
+**如何在中间方法中使用 MEET**：首先，我们将给定数组简单地分为两个相等的部分，然后我们为数组的两个部分生成所有可能的子集，并为每个子集存储元素乘积的值 分别分成两个向量（例如，subset1 & subset2）。 现在，这将花费 O（2 <sup>n / 2</sup> ）时间复杂度。 现在，如果我们对这两个向量（子集 1 &子集 2）进行排序，每个向量具有（2 <sup>n / 2</sup> ）个元素，那么这将花费 O（2 <sup>n / 2</sup> * log2 <sup>n / 2</sup> ）≈O（n *（2 <sup>n / 2</sup> ））时间复杂度。 在下一步中，我们遍历一个具有 2 个 <sup>n / 2</sup> 个元素的向量 subset1，并在第二个向量中找到 k / subset1 [i]的上限，这将告诉我们乘积小于 或等于 k。 因此，对于子集 1 中的每个元素，我们将尝试在子集 2 中以 upper_bound 的形式执行二分搜索，从而再次导致时间复杂度为 O（n *（2 <sup>n / 2</sup> ））。 因此，如果我们尝试计算此方法的总体复杂度，则将有 O（n *（2 <sup>n / 2</sup> ）+ n *（2 <sup>n / 2</sup> ）+ n * （2 <sup>n / 2</sup> ））≈O（n *（2 <sup>n / 2</sup> ））作为我们的时间复杂度，这比蛮力法效率高得多。
 
 **算法**：
 

docs/array/182.md

@@ -6,7 +6,7 @@
 
 为了使数组成为回文，我们可以简单地将合并操作应用 n-1 次，其中 n 是数组的大小（请注意，单个元素数组总是回文，类似于单个字符串）。 在这种情况下，数组的大小将减小为 1。但是在这个问题上，我们被要求以最少的操作数来完成。
 
-**范例**：
+**示例**：
 
 ```
 Input : arr[] = {15, 4, 15}
@@ -276,7 +276,7 @@ class GFG
 
 ```
 
-## 的 PHP
+## PHP
 
 ```
 

docs/array/184.md

@@ -205,7 +205,7 @@ class GFG {
 
 ```
 
-## 的 PHP
+## PHP
 
 ```
 

docs/array/186.md

@@ -8,7 +8,7 @@
 
 给定两个数字 a 和 b，请使用小于 O（| b – a |）的空间标记 a 和 b 之间 2 和 5 的倍数，并输出每个倍数。
 **注意**：我们必须将**的倍数标记为**，即将（键，值）对保存在内存中，以便每个键的值都为 1 或 0，表示 2 或 2 的倍数 5 或没有。
-**范例**：****
+**示例**：****
 
 ```
 Input : 2 10
@@ -171,7 +171,7 @@ class GFG {
 
 ```
 
-## 的 PHP
+## PHP
 
 ```
 

docs/array/189.md

@@ -197,7 +197,7 @@ class AlternativeString {
 
 ```
 
-## 的 PHP
+## PHP
 
 ```
 

docs/array/19.md

@@ -22,7 +22,7 @@ Output: 1
 ## [推荐：请先在“ ***<u>实践</u>*** ”上解决它，然后再继续解决。](https://practice.geeksforgeeks.org/problems/minimum-element-in-a-sorted-and-rotated-array/0)
 
 一个简单的解决方案是遍历整个数组并找到最小值。 该解决方案需要 O（n）时间。
-我们可以使用二进制搜索在 O（Logn）中进行操作。 如果我们仔细看一下上面的示例，我们可以很容易地找出以下模式：
+我们可以使用二分搜索在 O（Logn）中进行操作。 如果我们仔细看一下上面的示例，我们可以很容易地找出以下模式：
 
 *   最小元素是前一个大于它的唯一元素。 如果没有先前的元素元素，则不会旋转（第一个元素最少）。 我们通过将此条件与第（mid-1）个和第（mid + 1）个元素进行比较来检查此条件。
 *   如果最小元素不在中间（既不是中也不是中+1），则最小元素位于左半部分或右半部分。

docs/array/191.md

@@ -29,7 +29,7 @@ Output :  arr[] = {6, 3, 2, 8}
 
 ## [推荐：请先在“ ***<u>实践</u>*** ”上解决它，然后再继续解决。](https://practice.geeksforgeeks.org/problems/sort-by-absolute-difference/0)
 
-想法是使用自平衡二进制搜索树。 我们遍历输入数组，对于每个元素，我们找到它与 x 的差异，并将差异作为键存储，并将元素存储为自平衡二叉搜索树中的值。 最后，我们遍历树并打印其顺序遍历，这是必需的输出。
+想法是使用自平衡二分搜索树。 我们遍历输入数组，对于每个元素，我们找到它与 x 的差异，并将差异作为键存储，并将元素存储为自平衡二叉搜索树中的值。 最后，我们遍历树并打印其顺序遍历，这是必需的输出。
 
 **C++ 实现**：
 在 C++ 中，通过[设置](http://quiz.geeksforgeeks.org/set-associative-containers-the-c-standard-template-library-stl/)，[映射](http://quiz.geeksforgeeks.org/map-associative-containers-the-c-standard-template-library-stl/)和[多重映射](http://quiz.geeksforgeeks.org/multimap-associative-containers-the-c-standard-template-library-stl/)实现自平衡 bianry-search-tree 。 我们拥有键值对（不仅是键），因此无法在此处使用 set。 我们也不能直接使用 map，因为单个键可以属于多个值，而 map 则允许键具有单个值。 因此，我们使用多图存储键值对，并且键可以有多个值。

docs/array/194.md

@@ -172,7 +172,7 @@ class GFG {
 
 ```
 
-## 的 PHP
+## PHP
 
 ```
 

docs/array/195.md

@@ -250,7 +250,7 @@ class GFG {
 
 ```
 
-## 的 PHP
+## PHP
 
 ```
 

docs/array/196.md

@@ -188,7 +188,7 @@ class GFG {
 
 ```
 
-## 的 PHP
+## PHP
 
 ```
 

docs/array/197.md

@@ -265,7 +265,7 @@ int main()
 *   将第一个索引和相应的 BST 计数存储在 2D 数组中。
 *   根据计数对 2D 数组进行排序（在平局的情况下使用索引）。
 
-**时间复杂度：如果使用[自平衡二进制搜索树](http://en.wikipedia.org/wiki/Self-balancing_binary_search_tree)，则** O（nlogn）。 这在 [Set 2](https://www.geeksforgeeks.org/sort-elements-by-frequency-set-2/) 中实现。
+**时间复杂度：如果使用[自平衡二分搜索树](http://en.wikipedia.org/wiki/Self-balancing_binary_search_tree)，则** O（nlogn）。 这在 [Set 2](https://www.geeksforgeeks.org/sort-elements-by-frequency-set-2/) 中实现。
 
 **第 2 组**：
 [按频率对元素进行排序| 组合 2](https://www.geeksforgeeks.org/sort-elements-by-frequency-set-2/)

docs/array/198.md

@@ -193,7 +193,7 @@ Explanation: Given array has two inversions:
 
     ```
 
-    ## 的 PHP
+    ## PHP
 
     ```
 

docs/array/199.md

@@ -280,7 +280,7 @@ static void minAbsSumPair(int []arr,
 
 ```
 
-## 的 PHP
+## PHP
 
 ```
 

docs/array/200.md

@@ -243,7 +243,7 @@ class GFG {
 
 ```
 
-## 的 PHP
+## PHP
 
 ```
 

docs/array/203.md

@@ -39,14 +39,14 @@ arr2 [] = {3，8，6，20，7}
 2）找到 m 和 n 中的较小者，并对较小的数组进行排序。
 3）将较小的数组复制到 U。
 4）对于较大数组的每个元素 x，请按照
-进行…….b）在较小数组中二进制搜索 x。 如果 x 不存在，则将其复制到 U。
+进行…….b）在较小数组中二分搜索 x。 如果 x 不存在，则将其复制到 U。
 5）返回 U。
 
 ***交集**：*
 1）将交集 I 初始化为空。
 2）找到 m 和 n 中的较小者，并对较小的数组进行排序。
 3）对于较大数组的每个元素 x，请按照
-…….b）在较小数组中进行二进制搜索 x。 如果存在 x，则将其复制到 I。
+…….b）在较小数组中进行二分搜索 x。 如果存在 x，则将其复制到 I。
 4）返回 I。
 
 该方法的时间复杂度是 min（mLogm + nLogm，mLogn + nLogn），也可以写成 O（（m + n）Logm，（m + n）Logn）。 当两个数组的大小之间的差异很大时，此方法比以前的方法要好得多。
@@ -507,7 +507,7 @@ static public void Main ()
 
 ```
 
-## 的 PHP
+## PHP
 
 ```
 

docs/array/204.md

@@ -374,7 +374,7 @@ Output: {0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 2, 2}
 
     ```
 
-    ## 的 PHP
+    ## PHP
 
     ```
 

docs/array/206.md

@@ -21,11 +21,11 @@ After reading 4th element of stream - 5, 15, 1, 3 -> median - 4, so on...
 
 如果我们可以对显示的数据进行排序，则可以轻松地找到中值元素。 *插入排序*是一种在线算法，用于对到目前为止出现的数据进行排序。 在任何排序实例中，例如，在对第*个*个元素进行排序之后，将对数组的第一个*第*个元素进行排序。 在此之前，插入排序并不依赖将来的数据来对输入的数据进行排序。 换句话说，插入排序考虑到插入下一个元素时到目前为止已排序的数据。 这是使其成为在线算法的插入排序的关键部分。
 
-但是，插入排序需要 O（n <sup>2</sup> ）时间来对 *n* 个元素进行排序。 也许我们可以对*插入排序*使用*二进制搜索*来查找 O（log n）时间中下一个元素的位置。 但是，我们无法在 O（log n）时间内进行数据移动。 无论实现的效率如何，在插入排序的情况下都需要多项式时间。
+但是，插入排序需要 O（n <sup>2</sup> ）时间来对 *n* 个元素进行排序。 也许我们可以对*插入排序*使用*二分搜索*来查找 O（log n）时间中下一个元素的位置。 但是，我们无法在 O（log n）时间内进行数据移动。 无论实现的效率如何，在插入排序的情况下都需要多项式时间。
 
 有兴趣的读者可以尝试方法 1 的实现。
 
-**方法 2**：增强的自平衡二进制搜索树（AVL，RB 等）
+**方法 2**：增强的自平衡二分搜索树（AVL，RB 等）
 
 在 BST 的每个节点上，维护以该节点为根的子树中的元素数量。 我们可以将节点用作简单二叉树的根，其左子节点是具有小于根的元素的自平衡 BST，右子节点是具有大于根的元素的自平衡 BST。 根元素始终保持*有效中位数*。
 

docs/array/207.md

@@ -630,7 +630,7 @@ Explanation: There can be 6 possible triangles:
 
     ```
 
-    ## 的 PHP
+    ## PHP
 
     ```
 

docs/array/208.md

@@ -62,7 +62,7 @@ int countPairsBruteForce(int X[], int Y[], int m, int n)
 以下是基于此技巧的简单步骤。
 
 *   对数组 Y []进行排序。
-*   对于[[X]]中的每个 x，请使用**二进制搜索**查找 Y []中大于 x 的最小数字的索引 idx（也称为 x 的 ceil），或者我们可以使用内置函数 [upper_bound（ ）](http://www.geeksforgeeks.org/stdupper_bound-in-cpp/)在算法库中。
+*   对于[[X]]中的每个 x，请使用**二分搜索**查找 Y []中大于 x 的最小数字的索引 idx（也称为 x 的 ceil），或者我们可以使用内置函数 [upper_bound（ ）](http://www.geeksforgeeks.org/stdupper_bound-in-cpp/)在算法库中。
 *   idx 之后的所有数字都满足关系，因此只需将（n-idx）添加到计数中即可。
 
 **基本情况和例外**：

docs/array/209.md

@@ -181,7 +181,7 @@ class GFG {
 
 ```
 
-## 的 PHP
+## PHP
 
 ```
 
@@ -549,7 +549,7 @@ function countPairsWithDiffK($arr, $n, $k)
 Count of pairs with given diff is 2
 ```
 
-时间复杂度：第一步（排序）需要 O（nLogn）时间。 第二步运行二进制搜索 n 次，因此第二步的时间复杂度也是 O（nLogn）。 因此，总体时间复杂度为 O（nLogn）。 第二步可以优化为 O（n），请参见。
+时间复杂度：第一步（排序）需要 O（nLogn）时间。 第二步运行二分搜索 n 次，因此第二步的时间复杂度也是 O（nLogn）。 因此，总体时间复杂度为 O（nLogn）。 第二步可以优化为 O（n），请参见。
 
 **方法 3（使用自平衡 BST）**
 我们也可以使用自平衡 BST（例如 [AVL 树](https://www.geeksforgeeks.org/avl-tree-set-1-insertion/)或红黑树）来解决此问题。 以下是详细的算法。

docs/array/211.md

@@ -144,7 +144,7 @@ class PairSum
 
 ```
 
-## 的 PHP
+## PHP
 
 ```
 

docs/array/213.md

@@ -204,7 +204,7 @@ class GfG
 
 ```
 
-## 的 PHP
+## PHP
 
 ```
 

docs/array/214.md

@@ -28,7 +28,7 @@ divisible by 2 in between them.
 **天真方法**会遍历所有可能的对，并计算在它们之间具有 k 个整数的对数，这些整数可被 x 整除。
 **时间复杂度**： O（n ^ 2）
 
-**有效方法**是对数组进行排序，然后使用[二进制搜索](https://www.geeksforgeeks.org/binary-search/)找出数字的左右边界（使用 [lower_bound 函数](https://www.geeksforgeeks.org/upper_bound-and-lower_bound-for-vector-in-cpp-stl/)内置函数可以做到） 满足条件而哪些不满足。 我们必须对数组进行排序，因为给出的每对数组均应为 a [j] > = a [i]，而与 i 和 j 的值无关。 排序后，我们遍历 n 个元素，并找到与 x 相乘得到 a [i] -1 的数字，以便我们可以通过将 d 加到 d = a [i] -1 / x 来找到 k 个数。 因此，我们对值（d + k）* x 进行二进制搜索，以获取可以构成一对 a [i]的倍数，因为它将在 a [i]和 a [j]之间恰好有 k 个整数。 这样，我们在 O（log n）中使用二进制搜索获得 a [j]的左边界，对于所有其他可能使用 a [i]的对，我们需要通过搜索等于的数来找出最右边界 等于或大于（d + k + 1）* x，在这里我们将得到 k + 1 倍，并且我们得到的结对数（作为（左右方向）边界）。
+**有效方法**是对数组进行排序，然后使用[二分搜索](https://www.geeksforgeeks.org/binary-search/)找出数字的左右边界（使用 [lower_bound 函数](https://www.geeksforgeeks.org/upper_bound-and-lower_bound-for-vector-in-cpp-stl/)内置函数可以做到） 满足条件而哪些不满足。 我们必须对数组进行排序，因为给出的每对数组均应为 a [j] > = a [i]，而与 i 和 j 的值无关。 排序后，我们遍历 n 个元素，并找到与 x 相乘得到 a [i] -1 的数字，以便我们可以通过将 d 加到 d = a [i] -1 / x 来找到 k 个数。 因此，我们对值（d + k）* x 进行二分搜索，以获取可以构成一对 a [i]的倍数，因为它将在 a [i]和 a [j]之间恰好有 k 个整数。 这样，我们在 O（log n）中使用二分搜索获得 a [j]的左边界，对于所有其他可能使用 a [i]的对，我们需要通过搜索等于的数来找出最右边界 等于或大于（d + k + 1）* x，在这里我们将得到 k + 1 倍，并且我们得到的结对数（作为（左右方向）边界）。
 
 ## C++ 
 

docs/array/216.md

@@ -244,7 +244,7 @@ public static void Main()
 
 ```
 
-## 的 PHP
+## PHP
 
 ```
 

docs/array/218.md

@@ -208,7 +208,7 @@ public class GFG {
 
 ```
 
-## 的 PHP
+## PHP
 
 ```
 

docs/array/220.md

@@ -237,7 +237,7 @@ public static void Main()
 
 ```
 
-## 的 PHP
+## PHP
 
 ```
 

docs/array/221.md

@@ -302,7 +302,7 @@ public static void Main()
 
 ```
 
-## 的 PHP
+## PHP
 
 ```
 

docs/array/223.md

@@ -232,7 +232,7 @@ public static void Main ()
 
 ```
 
-## 的 PHP
+## PHP
 
 ```
 

docs/array/225.md

@@ -230,7 +230,7 @@ class GFG {
 
 ```
 
-## 的 PHP
+## PHP
 
 ```
 

docs/array/226.md

@@ -214,7 +214,7 @@ public class GFG {
 
 ```
 
-## 的 PHP
+## PHP
 
 ```
 

docs/array/23.md

@@ -210,7 +210,7 @@ class GFG
 
 ```
 
-## 的 PHP
+## PHP
 
 ```
 

docs/array/233.md

@@ -272,7 +272,7 @@ public class GfG {
 
 ```
 
-## 的 PHP
+## PHP
 
 ```
 

docs/array/238.md

@@ -229,7 +229,7 @@ class GFG {
 
 ```
 
-## 的 PHP
+## PHP
 
 ```
 

docs/array/240.md

@@ -338,7 +338,7 @@ class MAIN
 
 ```
 
-## 的 PHP
+## PHP
 
 ```
 

docs/array/241.md

@@ -240,7 +240,7 @@ public class GFG {
 
 ```
 
-## 的 PHP
+## PHP
 
 ```
 

docs/array/245.md

@@ -152,7 +152,7 @@ class GFG
 
 ```
 
-## 的 PHP
+## PHP
 
 ```
 

docs/array/249.md

@@ -212,7 +212,7 @@ class main
 
 ```
 
-## 的 PHP
+## PHP
 
 ```
 

docs/array/250.md

@@ -8,7 +8,7 @@
 
 **搜索操作**
 
-在排序数组中，可以使用[二进制搜索](http://quiz.geeksforgeeks.org/binary-search/)来执行搜索操作。
+在排序数组中，可以使用[二分搜索](http://quiz.geeksforgeeks.org/binary-search/)来执行搜索操作。
 
 ![](img/c0f4731d3e0cb3c5d181088760286a87.png)
 
@@ -204,7 +204,7 @@ public class GFG {
 
 ```
 
-## 的 PHP
+## PHP
 
 ```
 

docs/array/251.md

@@ -430,7 +430,7 @@ class GFG {
 
 ```
 
-## 的 PHP
+## PHP
 
 ```
 

docs/array/252.md

@@ -243,7 +243,7 @@ class GFG {
 
 ```
 
-## 的 PHP
+## PHP
 
 ```
 

docs/array/253.md

@@ -262,7 +262,7 @@ class GFG {
 
 ```
 
-## 的 PHP
+## PHP
 
 ```
 

docs/array/254.md

@@ -6,12 +6,12 @@
 
 资料来源：Amazon Interview Experience。
 
-由于数组已排序，因此首先想到的是二进制搜索，但是这里的问题是我们不知道数组的大小。
-如果数组是无限的，则意味着我们没有适当的界限来应用二进制搜索。 因此，为了找到键的位置，我们首先找到边界，然后应用二进制搜索算法。
+由于数组已排序，因此首先想到的是二分搜索，但是这里的问题是我们不知道数组的大小。
+如果数组是无限的，则意味着我们没有适当的界限来应用二分搜索。 因此，为了找到键的位置，我们首先找到边界，然后应用二分搜索算法。
 
 让 low 指向数组的第一个元素，high 指向数组的第二个元素，现在将键与高索引元素进行比较，如果
 ->大于高索引元素，则将高索引复制到低索引中并将高两倍 指数。
-->如果较小，则对找到的高低索引进行二进制搜索。
+->如果较小，则对找到的高低索引进行二分搜索。
 
 ## [推荐：在继续进行解决之前，请先在 ***<u>{IDE}</u>*** 上尝试您的方法。](https://ide.geeksforgeeks.org/)
 
@@ -289,7 +289,7 @@ class GFG {
 
 ```
 
-## 的 PHP
+## PHP
 
 ```
 

docs/array/256.md

@@ -4,7 +4,7 @@
 
 给定一个整数数组。 除了一个数字出现一次以外，所有数字出现两次。 在 O（n）时间&恒定的额外空间中找到数字。
 
-**范例**：
+**示例**：
 
 ```
 Input:  ar[] = {7, 3, 5, 4, 5, 3, 4}

docs/array/257.md

@@ -377,7 +377,7 @@ class GFG {
 
 ```
 
-## 的 PHP
+## PHP
 
 ```
 
@@ -488,7 +488,7 @@ The Maximum Subarray Sum = 7
 这种方法的时间复杂度为 O（n * m）
 
 **方法 2（O（（n + m）* log（m））方法）**
-该方法背后的主要思想与方法 1 完全相同。 使用 **[二进制搜索](http://www.geeksforgeeks.org/binary-search/)**
+该方法背后的主要思想与方法 1 完全相同。 使用 **[二分搜索](http://www.geeksforgeeks.org/binary-search/)**
 ，可以更快地使用数组 B 中的数组 A 的元素。
 
 ## C++

docs/array/259.md

@@ -4,7 +4,7 @@
 
 数组的平衡索引是一个索引，以使较低索引处的元素之和等于较高索引处的元素之和。 例如，在数组 A 中：
 
-**范例**：
+**示例**：
 
 > **输入**：A [] = {-7、1、5、2，-4、3、0}
 > **输出**：3

docs/array/261.md

@@ -3,7 +3,7 @@
 > 原文： [https://www.geeksforgeeks.org/ceiling-in-a-sorted-array/](https://www.geeksforgeeks.org/ceiling-in-a-sorted-array/)
 
 给定一个排序数组和一个值 x，x 的上限是数组中大于或等于 x 的最小元素，下限是小于或等于 x 的最大元素。 假设数组以非降序排序。 编写有效的函数以查找 x 的底和顶。
- **范例**：
+ **示例**：
 
 ```
 For example, let the input array be {1, 2, 8, 10, 10, 12, 19}

docs/array/262.md

@@ -3,7 +3,7 @@
 > 原文： [https://www.geeksforgeeks.org/majority-element/](https://www.geeksforgeeks.org/majority-element/)
 
 编写一个接受数组并打印多数元素（如果存在）的函数，否则打印“无多数元素”。 大小为 n 的数组 A []中的 ***多数元素*** 是出现超过 n / 2 次的元素（因此，最多有一个这样的元素）。
-**范例**：
+**示例**：
 
 ```
 Input : {3, 3, 4, 2, 4, 4, 2, 4, 4}
@@ -251,7 +251,7 @@ greater than the half of the size of the array size.
 
     ```
 
-    ## 的 PHP
+    ## PHP
 
     ```
 
@@ -316,11 +316,11 @@ greater than the half of the size of the array size.
     *   **辅助空间**： O（1）。
         由于任何操作都不需要额外的空间，因此空间复杂度是恒定的。
 
-<u>**方法 2（使用[二进制搜索树](https://www.geeksforgeeks.org/binary-search-tree-set-1-search-and-insertion/)）**</u>
+<u>**方法 2（使用[二分搜索树](https://www.geeksforgeeks.org/binary-search-tree-set-1-search-and-insertion/)）**</u>
 
 *   **方法**：在 BST 中一个接一个地插入元素，如果已经存在一个元素，则增加节点的计数。 在任何阶段，如果节点数超过 n / 2，则返回。
 *   **算法**：
-    1.  创建一个二进制搜索树，如果在二进制搜索树中输入相同的元素，则节点的频率会增加。
+    1.  创建一个二分搜索树，如果在二分搜索树中输入相同的元素，则节点的频率会增加。
     2.  遍历数组并将元素插入二叉搜索树。
     3.  如果任何节点的最大频率大于数组大小的一半，则执行有序遍历并找到频率大于一半的节点
     4.  其他打印无多数元素。
@@ -419,7 +419,7 @@ greater than the half of the size of the array size.
     ```
 
 *   **复杂度分析**：
-    *   **时间复杂度**：如果使用[二进制搜索树](https://www.geeksforgeeks.org/binary-search-tree-set-1-search-and-insertion/)，则时间复杂度将为 O（n ^ 2）。 如果使用[自平衡二进制搜索](http://en.wikipedia.org/wiki/Self-balancing_binary_search_tree)树，则其为 O（nlogn）
+    *   **时间复杂度**：如果使用[二分搜索树](https://www.geeksforgeeks.org/binary-search-tree-set-1-search-and-insertion/)，则时间复杂度将为 O（n ^ 2）。 如果使用[自平衡二分搜索](http://en.wikipedia.org/wiki/Self-balancing_binary_search_tree)树，则其为 O（nlogn）
     *   **辅助空间**： O（n）。
         由于需要额外的空间才能将数组存储在树中。
 

docs/array/263.md

@@ -193,7 +193,7 @@ class GFG {
 
 ```
 
-## 的 PHP
+## PHP
 
 ```
 
@@ -251,8 +251,8 @@ Output :
 
 **时间复杂度**： O（n）
 
-**方法 2（使用二进制搜索）**
-使用二进制搜索方法来查找给定数字的第一个匹配项。 二进制搜索的标准在这里很重要。
+**方法 2（使用二分搜索）**
+使用二分搜索方法来查找给定数字的第一个匹配项。 二分搜索的标准在这里很重要。
 
 ## C
 

docs/array/266.md

@@ -89,7 +89,7 @@ Index of a peak point is 2
 *   **空间复杂度**： O（1）。
     不需要多余的空间，因此空间复杂度是恒定的
 
-<u>**高效方法**：</u> [分而治之](https://www.geeksforgeeks.org/divide-and-conquer-set-1-find-closest-pair-of-points/)可用于查找 O（Logn）时间的峰值。 这个想法是基于二进制搜索技术来检查中间元素是否是峰值元素。 如果中间元素不是峰值元素，则检查右侧的元素是否大于中间元素，那么右侧总是存在一个峰值元素。 如果左侧的元素大于中间的元素，则左侧总是有一个峰值元素。 形成递归，峰值元素可以在 log n 个时间内找到。
+<u>**高效方法**：</u> [分而治之](https://www.geeksforgeeks.org/divide-and-conquer-set-1-find-closest-pair-of-points/)可用于查找 O（Logn）时间的峰值。 这个想法是基于二分搜索技术来检查中间元素是否是峰值元素。 如果中间元素不是峰值元素，则检查右侧的元素是否大于中间元素，那么右侧总是存在一个峰值元素。 如果左侧的元素大于中间的元素，则左侧总是有一个峰值元素。 形成递归，峰值元素可以在 log n 个时间内找到。
 
 **Algorithm:**
 
@@ -394,7 +394,7 @@ class GFG {
 
 ```
 
-## 的 PHP
+## PHP
 
 ```
 
@@ -465,7 +465,7 @@ Index of a peak point is 2
 **复杂度分析**：
 
 *   **时间复杂度**： O（登录）。
-    其中 n 是输入数组中元素的数量。 在每一步中，我们的搜索将变成一半。 因此可以将其与二进制搜索进行比较，因此时间复杂度为 O（log n）
+    其中 n 是输入数组中元素的数量。 在每一步中，我们的搜索将变成一半。 因此可以将其与二分搜索进行比较，因此时间复杂度为 O（log n）
 *   **空间复杂度**： O（1）。
     不需要额外的空间，因此空间复杂度是恒定的。
 

docs/array/269.md

@@ -294,7 +294,7 @@ class GFG {
 
 ```
 
-## 的 PHP
+## PHP
 
 ```
 

docs/array/270.md

@@ -154,7 +154,7 @@ class GFG {
 
 ```
 
-## 的 PHP
+## PHP
 
 ```
 

docs/array/271.md

@@ -393,7 +393,7 @@ class GFG
 
 ```
 
-## 的 PHP
+## PHP
 
 ```
 

docs/array/272.md

@@ -274,7 +274,7 @@ in the array whose sum is 9\.
 
     ```
 
-    ## 的 PHP
+    ## PHP
 
     ```
 

docs/array/273.md

@@ -220,7 +220,7 @@ Explanation : The triplets with zero sum is
 
     ```
 
-    ## 的 PHP
+    ## PHP
 
     ```
 

docs/array/276.md

@@ -240,7 +240,7 @@ class GFG
 
 ```
 
-## 的 PHP
+## PHP
 
 ```
 

docs/array/278.md

@@ -270,7 +270,7 @@ public class GFG {
 
 ```
 
-## 的 PHP
+## PHP
 
 ```
 

docs/array/280.md

@@ -164,7 +164,7 @@ Explanation: The missing number from 1 to 5 is 4
 
     ```
 
-    ## 的 PHP
+    ## PHP
 
     ```
 

docs/array/282.md

@@ -252,7 +252,7 @@ class GFG {
 
 ```
 
-## 的 PHP
+## PHP
 
 ```
 

docs/array/283.md

@@ -199,7 +199,7 @@ class GFG {
 
 ```
 
-## 的 PHP
+## PHP
 
 ```
 

docs/array/284.md

@@ -22,7 +22,7 @@ Output: 6 [6 is the first element that repeats]
 我们可以**使用排序**解决 O（nLogn）时间的问题。 以下是详细步骤。
 1）将给定数组复制到辅助数组 temp []。
 2）使用 O（nLogn）时间排序算法对临时数组进行排序。
-3）从左到右扫描输入数组。 对于每个元素，[使用二进制搜索](https://www.geeksforgeeks.org/count-number-of-occurrences-in-a-sorted-array/)在 temp []中计算其出现次数。 一旦发现一个元素出现多次，我们将返回该元素。 此步骤可以在 O（nLogn）时间完成。
+3）从左到右扫描输入数组。 对于每个元素，[使用二分搜索](https://www.geeksforgeeks.org/count-number-of-occurrences-in-a-sorted-array/)在 temp []中计算其出现次数。 一旦发现一个元素出现多次，我们将返回该元素。 此步骤可以在 O（nLogn）时间完成。
 
 我们可以**使用[散列](http://geeksquiz.com/hashing-set-1-introduction/)** 来平均解决 O（n）时间。 这个想法是从右到左遍历给定的数组，并在我们找到在右侧访问过的元素时更新最小索引。 感谢 Mohammad Shahid 提出了此解决方案。
 

docs/array/285.md

@@ -22,9 +22,9 @@ Output: 6
 
 一种**简单解决方案**是遍历数组并逐元素检查元素，并在发现不匹配项时标记缺少的元素，但是此解决方案需要整个数组长度的线性时间。
 
-另一种**有效解决方案**基于[二进制搜索](http://geeksquiz.com/binary-search/)方法。 算法步骤如下：
+另一种**有效解决方案**基于[二分搜索](http://geeksquiz.com/binary-search/)方法。 算法步骤如下：
 
-1.  在更大的数组中开始二进制搜索，并获得（lo + hi）/ 2 的中间值
+1.  在更大的数组中开始二分搜索，并获得（lo + hi）/ 2 的中间值
 2.  如果两个数组的值相同，则缺少的元素必须在右侧，因此将 lo 设置为 mid
 3.  否则将 hi 设置为 mid，因为如果 mid 元素不相等，则缺少的元素必须位于较大数组的左侧。
 4.  对于单元素和零元素数组，特殊情况将分别处理，单元素本身将是缺少的元素。

docs/array/286.md

@@ -245,7 +245,7 @@ Output: Missing = 5, Repeating = 1
 
     ```
 
-    ## 的 PHP
+    ## PHP
 
     ```
 

docs/array/288.md

@@ -19,7 +19,7 @@ Output: No Such Pair
 
 最简单的方法是运行两个循环，外循环选择第一个元素（较小的元素），内循环查找外循环加上 n 拾取的元素。 该方法的时间复杂度为 O（n ^ 2）。
 
-我们可以使用排序和二进制搜索将时间复杂度提高到 O（nLogn）。 第一步是按升序对数组进行排序。 数组排序后，从左到右遍历该数组，对于每个元素 arr [i]，在 arr [i + 1..n-1]中对 arr [i] + n 进行二进制搜索。 如果找到该元素，则返回该对。
+我们可以使用排序和二分搜索将时间复杂度提高到 O（nLogn）。 第一步是按升序对数组进行排序。 数组排序后，从左到右遍历该数组，对于每个元素 arr [i]，在 arr [i + 1..n-1]中对 arr [i] + n 进行二分搜索。 如果找到该元素，则返回该对。
 第一步和第二步都采用 O（nLogn）。 因此，总体复杂度为 O（nLogn）。
 
 上述算法的第二步可以提高到 O（n）。 第一步保持不变。 第二步的想法是采用两个索引变量 i 和 j，分别将它们初始化为 0 和 1。 现在运行一个线性循环。 如果 arr [j] – arr [i]小于 n，我们需要寻找更大的 arr [j]，因此增加 j。 如果 arr [j] – arr [i]大于 n，则需要寻找更大的 arr [i]，因此增加 i。 感谢 Aashish Barnwal 提出了这种方法。

docs/array/292.md

@@ -222,7 +222,7 @@ public class GFG
 
 ```
 
-## 的 PHP
+## PHP
 
 ```
 

docs/array/293.md

@@ -3,7 +3,7 @@
 > 原文： [https://www.geeksforgeeks.org/third-largest-element-array-distinct-elements/](https://www.geeksforgeeks.org/third-largest-element-array-distinct-elements/)
 
 给定 n 个整数数组，找到第三大元素。 数组中的所有元素都是不同的整数。
-**范例**：
+**示例**：
 
 ```
 Input: arr[] = {1, 14, 2, 16, 10, 20}
@@ -264,7 +264,7 @@ and third largest element is 16
 
     ```
 
-    ## 的 PHP
+    ## PHP
 
     ```
 

docs/array/294.md

@@ -273,7 +273,7 @@ class GFG
 
 ```
 
-## 的 PHP
+## PHP
 
 ```