“倒叙” -> “倒序”

problems/0031.下一个排列.md

@@ -86,7 +86,7 @@ public:
                 }
             }
         }
-        // 到这里了说明整个数组都是倒叙了，反转一下便可
+        // 到这里了说明整个数组都是倒序了，反转一下便可
         reverse(nums.begin(), nums.end());
     }
 };

problems/0151.翻转字符串里的单词.md

@@ -40,7 +40,7 @@
 
 不能使用辅助空间之后，那么只能在原字符串上下功夫了。
 
-想一下，我们将整个字符串都反转过来，那么单词的顺序指定是倒序了，只不过单词本身也倒叙了，那么再把单词反转一下，单词不就正过来了。
+想一下，我们将整个字符串都反转过来，那么单词的顺序指定是倒序了，只不过单词本身也倒序了，那么再把单词反转一下，单词不就正过来了。
 
 所以解题思路如下：
 

problems/0344.反转字符串.md

@@ -101,7 +101,6 @@ s[j] = tmp;
 s[i] ^= s[j];
 s[j] ^= s[i];
 s[i] ^= s[j];
-
 ```
 
 这道题目还是比较简单的，但是我正好可以通过这道题目说一说在刷题的时候，使用库函数的原则。

problems/0347.前K个高频元素.md

@@ -107,7 +107,7 @@ public:
             }
         }
 
-        // 找出前K个高频元素，因为小顶堆先弹出的是最小的，所以倒叙来输出到数组
+        // 找出前K个高频元素，因为小顶堆先弹出的是最小的，所以倒序来输出到数组
         vector<int> result(k);
         for (int i = k - 1; i >= 0; i--) {
             result[i] = pri_que.top().first;
@@ -180,7 +180,7 @@ class Solution:
             if len(pri_que) > k: #如果堆的大小大于了K，则队列弹出，保证堆的大小一直为k
                 heapq.heappop(pri_que)
         
-        #找出前K个高频元素，因为小顶堆先弹出的是最小的，所以倒叙来输出到数组
+        #找出前K个高频元素，因为小顶堆先弹出的是最小的，所以倒序来输出到数组
         result = [0] * k
         for i in range(k-1, -1, -1):
             result[i] = heapq.heappop(pri_que)[1]

problems/0416.分割等和子集.md

@@ -112,7 +112,7 @@ vector<int> dp(10001, 0);
 
 4. 确定遍历顺序
 
-在[动态规划：关于01背包问题，你该了解这些！（滚动数组）](https://programmercarl.com/背包理论基础01背包-2.html)中就已经说明：如果使用一维dp数组，物品遍历的for循环放在外层，遍历背包的for循环放在内层，且内层for循环倒叙遍历！
+在[动态规划：关于01背包问题，你该了解这些！（滚动数组）](https://programmercarl.com/背包理论基础01背包-2.html)中就已经说明：如果使用一维dp数组，物品遍历的for循环放在外层，遍历背包的for循环放在内层，且内层for循环倒序遍历！
 
 代码如下：
 

problems/0685.冗余连接II.md

@@ -68,7 +68,7 @@ for (int i = 0; i < n; i++) {
 
 ```cpp
 vector<int> vec; // 记录入度为2的边（如果有的话就两条边）
-// 找入度为2的节点所对应的边，注意要倒叙，因为优先返回最后出现在二维数组中的答案
+// 找入度为2的节点所对应的边，注意要倒序，因为优先返回最后出现在二维数组中的答案
 for (int i = n - 1; i >= 0; i--) {
     if (inDegree[edges[i][1]] == 2) {
         vec.push_back(i);
@@ -577,7 +577,7 @@ var findRedundantDirectedConnection = function(edges) {
         inDegree[edges[i][1]]++; // 统计入度
     }
     let vec = [];// 记录入度为2的边（如果有的话就两条边）
-    // 找入度为2的节点所对应的边，注意要倒叙，因为优先返回最后出现在二维数组中的答案
+    // 找入度为2的节点所对应的边，注意要倒序，因为优先返回最后出现在二维数组中的答案
     for (let i = n - 1; i >= 0; i--) {
         if (inDegree[edges[i][1]] == 2) {
             vec.push(i);

problems/0746.使用最小花费爬楼梯.md

@@ -82,7 +82,7 @@ dp[1] = cost[1];
 
 **但是稍稍有点难度的动态规划，其遍历顺序并不容易确定下来**。
 
-例如：01背包，都知道两个for循环，一个for遍历物品嵌套一个for遍历背包容量，那么为什么不是一个for遍历背包容量嵌套一个for遍历物品呢？ 以及在使用一维dp数组的时候遍历背包容量为什么要倒叙呢？
+例如：01背包，都知道两个for循环，一个for遍历物品嵌套一个for遍历背包容量，那么为什么不是一个for遍历背包容量嵌套一个for遍历物品呢？ 以及在使用一维dp数组的时候遍历背包容量为什么要倒序呢？
 
 **这些都是遍历顺序息息相关。当然背包问题后续「代码随想录」都会重点讲解的！**
 

problems/1047.删除字符串中的所有相邻重复项.md

@@ -63,7 +63,7 @@
 
 ![1047.删除字符串中的所有相邻重复项](https://code-thinking.cdn.bcebos.com/gifs/1047.删除字符串中的所有相邻重复项.gif)
 
-从栈中弹出剩余元素，此时是字符串ac，因为从栈里弹出的元素是倒叙的，所以在对字符串进行反转一下，就得到了最终的结果。
+从栈中弹出剩余元素，此时是字符串ac，因为从栈里弹出的元素是倒序的，所以在对字符串进行反转一下，就得到了最终的结果。
 
 C++代码 :
 

problems/1049.最后一块石头的重量II.md

@@ -87,7 +87,7 @@ vector<int> dp(15001, 0);
 4. 确定遍历顺序
 
 
-在[动态规划：关于01背包问题，你该了解这些！（滚动数组）](https://programmercarl.com/背包理论基础01背包-2.html)中就已经说明：如果使用一维dp数组，物品遍历的for循环放在外层，遍历背包的for循环放在内层，且内层for循环倒叙遍历！
+在[动态规划：关于01背包问题，你该了解这些！（滚动数组）](https://programmercarl.com/背包理论基础01背包-2.html)中就已经说明：如果使用一维dp数组，物品遍历的for循环放在外层，遍历背包的for循环放在内层，且内层for循环倒序遍历！
 
 代码如下：
 

problems/背包理论基础01背包-2.md

@@ -103,7 +103,7 @@ for(int i = 0; i < weight.size(); i++) { // 遍历物品
 
 为什么呢？
 
-**倒叙遍历是为了保证物品i只被放入一次！**。但如果一旦正序遍历了，那么物品0就会被重复加入多次！
+**倒序遍历是为了保证物品i只被放入一次！**。但如果一旦正序遍历了，那么物品0就会被重复加入多次！
 
 举一个例子：物品0的重量weight[0] = 1，价值value[0] = 15
 
@@ -115,9 +115,9 @@ dp[2] = dp[2 - weight[0]] + value[0] = 30
 
 此时dp[2]就已经是30了，意味着物品0，被放入了两次，所以不能正序遍历。
 
-为什么倒叙遍历，就可以保证物品只放入一次呢？
+为什么倒序遍历，就可以保证物品只放入一次呢？
 
-倒叙就是先算dp[2]
+倒序就是先算dp[2]
 
 dp[2] = dp[2 - weight[0]] + value[0] = 15  （dp数组已经都初始化为0）
 
@@ -125,7 +125,7 @@ dp[1] = dp[1 - weight[0]] + value[0] = 15
 
 所以从后往前循环，每次取得状态不会和之前取得状态重合，这样每种物品就只取一次了。
 
-**那么问题又来了，为什么二维dp数组历的时候不用倒叙呢？**
+**那么问题又来了，为什么二维dp数组历的时候不用倒序呢？**
 
 因为对于二维dp，dp[i][j]都是通过上一层即dp[i - 1][j]计算而来，本层的dp[i][j]并不会被覆盖！