Update

Author: youngyangyang04

README.md

@@ -152,246 +152,7 @@
 
 # 算法模板 
 
-## 二分查找法 
-
-```
-class Solution {
-public:
-    int searchInsert(vector<int>& nums, int target) {
-        int n = nums.size();
-        int left = 0;
-        int right = n; // 我们定义target在左闭右开的区间里，[left, right)  
-        while (left < right) { // 因为left == right的时候，在[left, right)是无效的空间
-            int middle = left + ((right - left) >> 1);
-            if (nums[middle] > target) {
-                right = middle; // target 在左区间，因为是左闭右开的区间，nums[middle]一定不是我们的目标值，所以right = middle，在[left, middle)中继续寻找目标值
-            } else if (nums[middle] < target) {
-                left = middle + 1; // target 在右区间，在 [middle+1, right)中
-            } else { // nums[middle] == target
-                return middle; // 数组中找到目标值的情况，直接返回下标
-            }
-        }
-        return right;
-    }
-};
-
-```
-
-## KMP
-
-```
-void kmp(int* next, const string& s){
-    next[0] = -1;
-    int j = -1;
-    for(int i = 1; i < s.size(); i++){
-        while (j >= 0 && s[i] != s[j + 1]) {
-            j = next[j];
-        }
-        if (s[i] == s[j + 1]) {
-            j++;
-        }
-        next[i] = j;
-    }
-}
-```
-
-## 二叉树 
-
-二叉树的定义：
-
-```
-struct TreeNode {
-    int val;
-    TreeNode *left;
-    TreeNode *right;
-    TreeNode(int x) : val(x), left(NULL), right(NULL) {}
-};
-```
-
-### 深度优先遍历（递归） 
-
-前序遍历（中左右）
-```
-void traversal(TreeNode* cur, vector<int>& vec) {
-    if (cur == NULL) return;
-    vec.push_back(cur->val);    // 中 ，同时也是处理节点逻辑的地方
-    traversal(cur->left, vec);  // 左
-    traversal(cur->right, vec); // 右
-}
-```
-中序遍历（左中右）
-```
-void traversal(TreeNode* cur, vector<int>& vec) {
-    if (cur == NULL) return;
-    traversal(cur->left, vec);  // 左
-    vec.push_back(cur->val);    // 中 ，同时也是处理节点逻辑的地方
-    traversal(cur->right, vec); // 右
-}
-```
-中序遍历（中左右）
-```
-void traversal(TreeNode* cur, vector<int>& vec) {
-    if (cur == NULL) return;
-    vec.push_back(cur->val);    // 中 ，同时也是处理节点逻辑的地方
-    traversal(cur->left, vec);  // 左
-    traversal(cur->right, vec); // 右
-}
-```
-
-### 深度优先遍历（迭代法）
-
-相关题解：[0094.二叉树的中序遍历](https://github.com/youngyangyang04/leetcode/blob/master/problems/0094.二叉树的中序遍历.md)
-
-前序遍历（中左右）
-```
-vector<int> preorderTraversal(TreeNode* root) {
-    vector<int> result;
-    stack<TreeNode*> st;
-    if (root != NULL) st.push(root);
-    while (!st.empty()) {
-        TreeNode* node = st.top();
-        if (node != NULL) {
-            st.pop();
-            if (node->right) st.push(node->right);  // 右
-            if (node->left) st.push(node->left);    // 左
-            st.push(node);                          // 中
-            st.push(NULL);                          
-        } else {
-            st.pop();
-            node = st.top();
-            st.pop();
-            result.push_back(node->val);            // 节点处理逻辑
-        }
-    }
-    return result;
-}
-
-```
-
-中序遍历（左中右）
-```
-vector<int> inorderTraversal(TreeNode* root) {
-    vector<int> result; // 存放中序遍历的元素
-    stack<TreeNode*> st;
-    if (root != NULL) st.push(root);
-    while (!st.empty()) {
-        TreeNode* node = st.top();
-        if (node != NULL) {
-            st.pop(); 
-            if (node->right) st.push(node->right);  // 右
-            st.push(node);                          // 中
-            st.push(NULL); 
-            if (node->left) st.push(node->left);    // 左
-        } else {
-            st.pop(); 
-            node = st.top(); 
-            st.pop();
-            result.push_back(node->val);            // 节点处理逻辑
-        }
-    }
-    return result;
-}
-```
-
-后序遍历（左右中）
-```
-vector<int> postorderTraversal(TreeNode* root) {
-    vector<int> result;
-    stack<TreeNode*> st;
-    if (root != NULL) st.push(root);
-    while (!st.empty()) {
-        TreeNode* node = st.top();
-        if (node != NULL) {
-            st.pop();
-            st.push(node);                          // 中
-            st.push(NULL);
-            if (node->right) st.push(node->right);  // 右
-            if (node->left) st.push(node->left);    // 左
-
-        } else {
-            st.pop();
-            node = st.top();
-            st.pop();
-            result.push_back(node->val);            // 节点处理逻辑
-        }
-    }
-    return result;
-}
-```
-### 广度优先遍历（队列）
-
-相关题解：[0102.二叉树的层序遍历](https://github.com/youngyangyang04/leetcode/blob/master/problems/0102.二叉树的层序遍历.md)
-
-```
-vector<vector<int>> levelOrder(TreeNode* root) {
-    queue<TreeNode*> que;
-    if (root != NULL) que.push(root);
-    vector<vector<int>> result;
-    while (!que.empty()) {
-        int size = que.size();
-        vector<int> vec;
-        for (int i = 0; i < size; i++) {// 这里一定要使用固定大小size，不要使用que.size()
-            TreeNode* node = que.front();
-            que.pop();
-            vec.push_back(node->val);   // 节点处理的逻辑
-            if (node->left) que.push(node->left);
-            if (node->right) que.push(node->right);
-        }
-        result.push_back(vec);
-    }
-    return result;
-}
-
-```
-
-
-
-可以直接解决如下题目：
-
-* [0102.二叉树的层序遍历](https://github.com/youngyangyang04/leetcode/blob/master/problems/0102.二叉树的层序遍历.md)
-* [0199.二叉树的右视图](https://github.com/youngyangyang04/leetcode/blob/master/problems/0199.二叉树的右视图.md)
-* [0637.二叉树的层平均值](https://github.com/youngyangyang04/leetcode/blob/master/problems/0637.二叉树的层平均值.md) 
-* [0104.二叉树的最大深度 （迭代法）](https://github.com/youngyangyang04/leetcode/blob/master/problems/0104.二叉树的最大深度.md)
-
-* [0111.二叉树的最小深度（迭代法）]((https://github.com/youngyangyang04/leetcode/blob/master/problems/0111.二叉树的最小深度.md))
-* [0222.完全二叉树的节点个数（迭代法）](https://github.com/youngyangyang04/leetcode/blob/master/problems/0222.完全二叉树的节点个数.md)
-
-### 二叉树深度
-
-```
-int getDepth(TreeNode* node) {
-    if (node == NULL) return 0;
-    return 1 + max(getDepth(node->left), getDepth(node->right));
-}
-```
-
-### 二叉树节点数量
-
-```
-int countNodes(TreeNode* root) {
-    if (root == NULL) return 0;
-    return 1 + countNodes(root->left) + countNodes(root->right);
-}
-```
-
-## 回溯算法 
-
-```
-backtracking() {
-    if (终止条件) {
-        存放结果;
-    }
-
-    for (选择：选择列表（可以想成树中节点孩子的数量）) {
-        递归，处理节点;
-        backtracking();
-        回溯，撤销处理结果
-    }
-}
-
-```
-
-（持续补充ing）
+[各类基础算法模板](https://github.com/youngyangyang04/leetcode/blob/master/problems/算法模板.md)
 
 # LeetCode 最强题解:
 
@@ -469,6 +230,7 @@ backtracking() {
 |[0617.合并二叉树](https://github.com/youngyangyang04/leetcode/blob/master/problems/0617.合并二叉树.md) |树 |简单|**递归** **迭代**|
 |[0637.二叉树的层平均值](https://github.com/youngyangyang04/leetcode/blob/master/problems/0637.二叉树的层平均值.md) |树 |简单|**广度优先搜索/队列**|
 |[0654.最大二叉树](https://github.com/youngyangyang04/leetcode/blob/master/problems/0654.最大二叉树.md) |树 |中等|**递归**|
+|[0685.冗余连接II](https://github.com/youngyangyang04/leetcode/blob/master/problems/0685.冗余连接II.md) | 并查集/树/图 |困难|**并查集**|
 |[0700.二叉搜索树中的搜索](https://github.com/youngyangyang04/leetcode/blob/master/problems/0700.二叉搜索树中的搜索.md) |树 |简单|**递归** **迭代**|
 |[0701.二叉搜索树中的插入操作](https://github.com/youngyangyang04/leetcode/blob/master/problems/0701.二叉搜索树中的插入操作.md) |树 |简单|**递归** **迭代**|
 |[0705.设计哈希集合](https://github.com/youngyangyang04/leetcode/blob/master/problems/0705.设计哈希集合.md) |哈希表 |简单|**模拟**|

pics/239.滑动窗口最大值.png

@@ -3,9 +3,31 @@ https://leetcode-cn.com/problems/permutations-ii/
 
 ## 思路 
 
-i > 0 && nums[i] == nums[i-1] && used[i-1] == false
+这道题目和46.全排列的区别在与**给定一个可包含重复数字的序列**，要返回**所有不重复的全排列**。
 
-这是最高效的，可以用 1 1 1 1 1  跑一个样例试试
+这里就涉及到去重了。 
+
+要注意**全排列是要取树的子节点的，如果是子集问题，就取树上的所有节点。**
+
+很多同学在去重上想不明白，其实很多题解也没有讲清楚，反正代码是能过的，感觉是那么回事，稀里糊涂的先把题目过了。
+
+这个去重为什么很难理解呢，**所谓去重，其实就是使用过的元素不能重复选取。** 这么一说好像很简单！
+
+但是什么又是“使用过”，我们把排列问题抽象为树形结构之后，**“使用过”在这个树形结构上是有两个维度的**，一个维度是同一树枝上使用过，一个维度是同一树层上使用过。
+
+**没有理解这两个层面上的“使用过” 是造成大家没有彻底理解去重的根本原因。**
+
+那么排列问题，既可以在 同一树层上的“使用过”来去重，也可以在同一树枝上的“使用过”来去重！
+
+理解这一本质，很多疑点就迎刃而解了。
+
+首先把示例中的 [1,1,2]，抽象为一棵树，然后在同一树层上对nums[i-1]使用过的话，进行去重如图：
+
+<img src='../pics/47.全排列II1.png' width=600> </img></div>
+
+图中我们对同一树层，前一位（也就是nums[i-1]）如果使用过，那么就进行去重。
+
+代码如下：
 
 ## C++代码
 
@@ -21,7 +43,11 @@ private:
         }
 
         for (int i = 0; i < nums.size(); i++) {
-            if (i > 0 && nums[i] == nums[i-1] && used[i-1] == false) {
+            // 这里理解used[i - 1]非常重要 
+            // used[i - 1] == true，说明同一树支nums[i - 1]使用过 
+            // used[i - 1] == false，说明同一树层nums[i - 1]使用过
+            // 如果同一树层nums[i - 1]使用过则直接跳过
+            if (i > 0 && nums[i] == nums[i - 1] && used[i - 1] == false) { 
                 continue;
             }
             if (used[i] == false) {
@@ -45,3 +71,39 @@ public:
     }
 };
 ```
+
+## 拓展
+
+大家发现，去重最为关键的代码为：
+
+```
+if (i > 0 && nums[i] == nums[i - 1] && used[i - 1] == false) { 
+    continue;
+}
+```
+
+可是如果把 `used[i - 1] == true` 也是正确的，去重代码如下：
+```
+if (i > 0 && nums[i] == nums[i - 1] && used[i - 1] == true) { 
+    continue;
+}
+```
+
+这是为什么呢，就是上面我刚说的，如果要对树层中前一位去重，就用`used[i - 1] == false`，如果要对树枝前一位去重用用`used[i - 1] == true`。
+
+**对于排列问题，树层上去重和树枝上去重，都是可以的，但是树层上去重效率更高！**
+
+这么说是不是有点抽象？
+
+来来来，我就用输入: [1,1,1] 来举一个例子。
+
+树层上去重(used[i - 1] == false)，的树形结构如下：
+
+<img src='../pics/47.全排列II2.png' width=600> </img></div>
+
+树枝上去重（used[i - 1] == true）的树型结构如下：
+
+<img src='../pics/47.全排列II3.png' width=600> </img></div>
+
+大家应该很清晰的看到，树层上去重非常彻底，效率很高，树枝上去重虽然最后可能得到答案，但是多做了很多无用搜索。
+