2020-07-05 22:17:22

docs/array/46.md

@@ -4,8 +4,8 @@
 
 给定一个数组，重新排列数组，使得：
 
-1.  如果索引 i 为偶数，则 arr [i] < = arr [i + 1]
-2.  如果索引 i 为奇数，则 arr [i] > = arr [i + 1]
+1.  如果索引`i`为偶数，则`arr[i] <= arr[i + 1]`
+2.  如果索引`i`为奇数，则`arr[i] >= arr[i + 1]`
 
 **注意**：可以有多个答案。
 
@@ -32,24 +32,19 @@ Output :arr[] = {4, 6, 1, 8, 2, 3}
 
 **简单解决方案**是按降序对数组进行排序，然后从第二个元素开始，交换相邻元素。
 
-一种有效的**解决方案**是根据给定条件遍历数组并交换元素。
-如果我们有一个长度为 n 的数组，那么我们将从索引 0 迭代到 n-2 并检查给定条件。
-在任何时间点，如果 i 为偶数且 arr [i] > arr [i + 1]，则我们交换 arr [i]和 arr [i + 1]。 类似地，如果 i 为奇数并且
-arr [i] < arr [i + 1]，则我们交换 arr [i]和 arr [i + 1]。
+一种有效的**解决方案**是根据给定条件遍历数组并交换元素。如果我们有一个长度为 n 的数组，那么我们将从索引 0 迭代到`n-2`并检查给定条件。在任何时间点，如果`i`为偶数且`arr[i] > arr[i + 1]`，则我们交换`arr[i]`和`arr[i + 1]`。 类似地，如果`i`为奇数并且`arr[i] < arr[i + 1]`，则我们交换`arr[i]`和`arr[i + 1]`。
 
-对于给定的示例：
-重排之前，arr [] = {2，3，4，5}
-开始遍历数组直到索引 2（n = 4）
+对于给定的示例：重排之前，`arr[] = {2, 3, 4, 5}`，开始遍历数组直到索引 2（`n = 4`）
 
 > **第一步**：
-> 在 i = 0 时，arr [i] = 2 且 arr [i + 1] =3。当 i 为偶数且 arr [i]时< arr [i + 1] ]，无需交换。
+> 在`i = 0`时，`arr[i] = 2`且`arr [i + 1] = 3`。当`i`为偶数且`arr[i] < arr[i + 1]`时，无需交换。
 > **第二步**：
-> 在 i = 1 时，arr [i] = 3 且 arr [i + 1] =4。由于 i 为奇数且 arr [i] < arr [ i + 1]，将它们交换。
-> 现在 arr [] = {2，4，3，5}
+> 在`i = 1`时，`arr[i] = 3`且`arr[i + 1] = 4`。由于`i`为奇数且`arr[i] < arr[i + 1]`，将它们交换。
+> 现在`arr [] = {2, 4, 3, 5}`
 > **第三步**：
-> 在 i = 2 时，arr [i] = 3 且 arr [i + 1] =5。因此，无需交换它们
+> 在`i = 2`时，`arr[i] = 3`且`arr[i + 1] = 5`。因此，无需交换它们
 
-重新排列后，arr [] = {2，4，3，5}
+重新排列后，`arr[] = {2, 4, 3, 5}`
 
 ## C++ 
 
@@ -345,7 +340,7 @@ After rearranging:
 
 ```
 
-**时间复杂度**： O（n）
+**时间复杂度**： `O(n)`
 
 **参考**：
 [describe.codechef.com/questions/43062/anuund-editorial](http://discuss.codechef.com/questions/43062/anuund-editorial)

docs/array/47.md

@@ -307,24 +307,24 @@ for ($i = 0; $i < $n; $i++)
 ```
 
 让我们在第一个示例上解释代码的工作。
-arr [] = {1，-3，5，6，-3，6，7，-4，9，10}
-我们声明两个变量为正 负的负数指向第零个位置，负的负数指向第一个位置
-正= 0 负数= 1
-在第一次迭代中，由于 a [4]小于零且正数= 4，正数会将 4 个位置移至第五个位置 。
-负数将移动 2 个位置，并以 a [3]指向第四位置。> 0
+`arr[] = {1, -3, 5, 6, -3, 6, 7, -4, 9, 10}`
+我们声明两个变量为正负，正数指向第零个位置，负数指向第一个位置
+正`= 0`，负数`= 1`
+在第一次迭代中，由于`a[4]`小于零且正数`= 4`，正数会将 4 个位置移至第五个位置 。
+负数将移动 2 个位置，并以`a[3] > 0`指向第四位置。
 我们将交换正和负位置值，因为它们小于数组的大小。
-第一次迭代后，数组变为 arr [] = {1，-3，5，-3，6，6，7，-4，9，10}
+第一次迭代后，数组变为`arr[] = {1, -3, 5, -3, 6, 6, 7, -4, 9, 10}`
 
 现在在第四位置的正点和在第三位置的负点
 在第二次迭代中，正值将移动 6 位，其值
 将比数组的大小大。
 负指针将向前移动两步，并将指向第五个位置。
-当正指针值变得大于数组大小时，我们将不执行任何交换操作并退出 while 循环。
+当正指针值变得大于数组大小时，我们将不执行任何交换操作并退出`while`循环。
 最终输出为
-arr [] = {1，-3，5，-3，6，6，7，-4，9，10}
+`arr[] = {1, -3, 5, -3, 6, 6, 7, -4, 9, 10}`
 
 **不维持相对顺序的示例**：
-{-1，-2，-3，-4，-5，6，7，8};
+`{-1, -2, -3, -4, -5, 6, 7, 8};`
 
 **另一种方法：-**
 的想法是找到一个不正确位置的正/负元素（即，在奇数位置为正，在偶数位置为负），然后找到符号相反的元素，即 在剩余数组中的错误位置，然后交换这两个元素。

docs/array/48.md

@@ -3,8 +3,8 @@
 > 原文： [https://www.geeksforgeeks.org/replace-every-array-element-by-multiplication-of-previous-and-next/](https://www.geeksforgeeks.org/replace-every-array-element-by-multiplication-of-previous-and-next/)
 
 给定一个整数数组，请使用前一个和下一个元素的乘积更新每个元素，但以下例外。
-a）第一个元素被替换为 first 和 second。
-b）将 last 元素替换为 last 和倒数第二乘积。
+a）第一个元素被替换为`first`和`second`。
+b）将`last`元素替换为`last`和倒数第二乘积。
 
 **示例**：
 
@@ -18,9 +18,9 @@ Output: arr[] = {6, 8, 15, 24, 30}
 
 资料来源：[前 25 个面试问题](https://www.geeksforgeeks.org/top-25-interview-questions/)
 
-一个简单的解决方案是创建一个辅助数组，将给定数组的内容复制到辅助数组。 最后遍历辅助数组并使用复制的值更新给定的数组。 此解决方案的时间复杂度为 O（n），但需要 O（n）额外空间。
+一个简单的解决方案是创建一个辅助数组，将给定数组的内容复制到辅助数组。 最后遍历辅助数组并使用复制的值更新给定的数组。 此解决方案的时间复杂度为`O(n)`，但需要`O(n)`额外空间。
 
-一个有效的解决方案可以解决 O（n）时间和 O（1）空间中的问题。 这个想法是跟踪循环中的前一个元素。
+一个有效的解决方案可以解决`O(n)`时间和`O(1)`空间中的问题。 这个想法是跟踪循环中的前一个元素。
 以下是此想法的实现。
 
 ## C

docs/array/49.md

@@ -2,13 +2,13 @@
 
 > 原文： [https://www.geeksforgeeks.org/shuffle-a-given-array/](https://www.geeksforgeeks.org/shuffle-a-given-array/)
 
-给定一个数组，编写一个程序以生成数组元素的随机排列。 还问这个问题为“洗牌”或“给定数组随机化”。 这里的 shuffle 意味着数组元素的每个排列都应该具有相同的可能性。
+给定一个数组，编写一个程序以生成数组元素的随机排列。 还问这个问题为“洗牌”或“给定数组随机化”。 这里的随机化意味着数组元素的每个排列都应该具有相同的可能性。
 
 ![shuffle-array](img/59ddf5216a59d4898c9e512c0da3cca6.png)
-令给定数组为 *arr []* 。 一个简单的解决方案是创建一个辅助数组 *temp []* ，该数组最初是 *arr []* 的副本。 从 *temp []* 中随机选择一个元素，将随机选择的元素复制到 *arr [0]* 中，然后从 *temp []* 中删除所选元素。 重复相同的过程 n 次，并将元素复制到 *arr [1]，arr [2]，…。* 此解决方案的时间复杂度为 O（n ^ 2）。
+令给定数组为`arr[]`。 一个简单的解决方案是创建一个辅助数组`temp[]`，该数组最初是`arr[]`的副本。 从`temp[]`中随机选择一个元素，将随机选择的元素复制到`arr[0]`中，然后从`temp[]`中删除所选元素。 重复相同的过程 n 次，并将元素复制到`arr[1], arr[2], …`。此解决方案的时间复杂度为`O（n ^ 2）`。
 
-[Fisher-Yates 混洗算法](http://en.wikipedia.org/wiki/Fisher%E2%80%93Yates_shuffle#The_modern_algorithm)在 O（n）时间复杂度下工作。 这里的假设是，给我们一个函数 rand（），它在 O（1）时间内生成随机数。
-的想法是从最后一个元素开始，将其与整个数组（包括最后一个）中随机选择的元素交换。 现在考虑从 0 到 n-2 的数组（大小减小 1），并重复该过程直到我们找到第一个元素。
+[Fisher-Yates 混洗算法](http://en.wikipedia.org/wiki/Fisher%E2%80%93Yates_shuffle#The_modern_algorithm)在`O(n)`时间复杂度下工作。 这里的假设是，给我们一个函数`rand()`，它在`O(1)`时间内生成随机数。
+的想法是从最后一个元素开始，将其与整个数组（包括最后一个）中随机选择的元素交换。 现在考虑从 0 到`n-2`的数组（大小减小 1），并重复该过程直到我们找到第一个元素。
 
 以下是详细的算法
 
@@ -320,20 +320,20 @@ randomize($arr, $n);
 7 8 4 6 3 1 2 5
 ```
 
-上面的函数假定 rand（）生成一个随机数。
+上面的函数假定`rand()`生成一个随机数。
 
-**时间复杂度**： O（n），假设函数 rand（）需要 O（1）时间。
+**时间复杂度**：`O(n)`，假设函数`rand()`需要`O(1)`时间。
 
 **这是如何工作的？**
-第 i 个元素（包括最后一个元素）到达最后位置的概率为 1 / n，因为我们在第一次迭代中随机选择了一个元素。
+第`i`个元素（包括最后一个元素）到达最后位置的概率为`1 / n`，因为我们在第一次迭代中随机选择了一个元素。
 
-通过将 i 元素分为两种情况，可以证明 ith 元素到达倒数第二个位置的概率为 1 / n。
-*情况 1：i = n-1（最后一个元素的索引）*：
+通过将`i`元素分为两种情况，可以证明 ith 元素到达倒数第二个位置的概率为`1 / n`。
+*情况 1：`i = n-1`（最后一个元素的索引）*：
 最后一个元素到达倒数第二个位置的概率为=（最后一个元素没有停留在其最后位置的概率 原始位置）x（再次选择在上一步中选择的索引以便交换最后一个元素的概率）
-因此，概率=（（n-1）/ n）x（1 /（n-1）） = 1 / n
-*情况 2：0 < i < n-1（非最后索引）*：
+因此，概率`= ((n-1) / n) x (1 / (n-1)) = 1 / n`
+*情况 2：`0 < i < n-1`（非最后索引）*：
 第 i 个元素移至第二位置的概率=（概率 第一个元素在上一次迭代中未被选择）x（在此迭代中选择第 i 个元素的概率）
-因此，概率=（（n-1）/ n）x（1 /（n-1））= 1 / n
+因此，概率`=((n-1) / n) x (1 / (n-1))= 1 / n`
 
 我们可以轻松地将上述证明推广到其他位置。