Merge branch 'youngyangyang04:master' into master

problems/0018.四数之和.md

@@ -354,6 +354,54 @@ class Solution {
 }
 ```
 
+Swift:
+```swift
+func fourSum(_ nums: [Int], _ target: Int) -> [[Int]] {
+    var res = [[Int]]()
+    var sorted = nums
+    sorted.sort()
+    for k in 0 ..< sorted.count {
+        // 这种剪枝不行,target可能是负数
+//            if sorted[k] > target {
+//                return res
+//            }
+        // 去重
+        if k > 0 && sorted[k] == sorted[k - 1] {
+            continue
+        }
+        
+        let target2 = target - sorted[k]
+        for i in (k + 1) ..< sorted.count {
+            if i > (k + 1) && sorted[i] == sorted[i - 1] {
+                continue
+            }
+            var left = i + 1
+            var right = sorted.count - 1
+            while left < right {
+                let sum = sorted[i] + sorted[left] + sorted[right]
+                if sum < target2 {
+                    left += 1
+                } else if sum > target2 {
+                    right -= 1
+                } else {
+                    res.append([sorted[k], sorted[i], sorted[left], sorted[right]])
+                    while left < right && sorted[left] == sorted[left + 1] {
+                        left += 1
+                    }
+                    while left < right && sorted[right] == sorted[right - 1]  {
+                        right -= 1
+                    }
+                    // 找到答案 双指针同时收缩
+                    left += 1
+                    right -= 1
+                }
+            }
+        }
+    }
+    return res
+}
+```
+
 -----------------------
 * 作者微信：[程序员Carl](https://mp.weixin.qq.com/s/b66DFkOp8OOxdZC_xLZxfw)
 * B站视频：[代码随想录](https://space.bilibili.com/525438321)

problems/0235.二叉搜索树的最近公共祖先.md

@@ -234,7 +234,15 @@ public:
 ## Java 
 
 递归法：
-
+```java
+class Solution {
+    public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
+        if (root.val > p.val && root.val > q.val) return lowestCommonAncestor(root.left, p, q);
+        if (root.val < p.val && root.val < q.val) return lowestCommonAncestor(root.right, p, q);
+        return root;
+    }
+}
+```
 
 迭代法：
 ```java

problems/0406.根据身高重建队列.md

@@ -209,8 +209,13 @@ Python：
 ```python
 class Solution:
     def reconstructQueue(self, people: List[List[int]]) -> List[List[int]]:
+    	# 先按照h维度的身高顺序从高到低排序。确定第一个维度
+        # lambda返回的是一个元组：当-x[0](维度h）相同时，再根据x[1]（维度k）从小到大排序
         people.sort(key=lambda x: (-x[0], x[1]))
         que = []
+	
+	# 根据每个元素的第二个维度k，贪心算法，进行插入
+        # people已经排序过了：同一高度时k值小的排前面。
         for p in people:
             que.insert(p[1], p)
         return que

problems/0450.删除二叉搜索树中的节点.md

@@ -118,10 +118,25 @@ public:
         if (root == nullptr) return root; // 第一种情况：没找到删除的节点，遍历到空节点直接返回了
         if (root->val == key) {
             // 第二种情况：左右孩子都为空（叶子节点），直接删除节点， 返回NULL为根节点
+            if (root->left == nullptr && root->right == nullptr) {
+                ///! 内存释放
+                delete root;
+                return nullptr;
+            }
             // 第三种情况：其左孩子为空，右孩子不为空，删除节点，右孩子补位 ，返回右孩子为根节点
-            if (root->left == nullptr) return root->right;
+            else if (root->left == nullptr) {
+                auto retNode = root->right;
+                ///! 内存释放
+                delete root;
+                return retNode;
+            }
             // 第四种情况：其右孩子为空，左孩子不为空，删除节点，左孩子补位，返回左孩子为根节点
-            else if (root->right == nullptr) return root->left;
+            else if (root->right == nullptr) {
+                auto retNode = root->left;
+                ///! 内存释放
+                delete root;
+                return retNode;
+            }
             // 第五种情况：左右孩子节点都不为空，则将删除节点的左子树放到删除节点的右子树的最左面节点的左孩子的位置
             // 并返回删除节点右孩子为新的根节点。
             else {
@@ -278,6 +293,32 @@ class Solution {
     }
 }
 ```
+```java
+// 解法2
+class Solution {
+  public TreeNode deleteNode(TreeNode root, int key) {
+    if (root == null) return root;
+    if (root.val == key) {
+      if (root.left == null) {
+        return root.right;
+      } else if (root.right == null) {
+        return root.left;
+      } else {
+        TreeNode cur = root.right;
+        while (cur.left != null) {
+          cur = cur.left;
+        }
+        cur.left = root.left;
+        root = root.right;
+        return root;
+      }
+    }
+    if (root.val > key) root.left = deleteNode(root.left, key);
+    if (root.val < key) root.right = deleteNode(root.right, key);
+    return root;
+  }
+}
+```
 
 ## Python 
 

problems/0501.二叉搜索树中的众数.md

@@ -429,6 +429,44 @@ class Solution {
     }
 }
 ```
+迭代法
+```java
+class Solution {
+    public int[] findMode(TreeNode root) {
+        TreeNode pre = null;
+        Stack<TreeNode> stack = new Stack<>();
+        List<Integer> result = new ArrayList<>();
+        int maxCount = 0;
+        int count = 0;
+        TreeNode cur = root;
+        while (cur != null || !stack.isEmpty()) {
+            if (cur != null) {
+                stack.push(cur);
+                cur =cur.left;
+            }else {
+                cur = stack.pop();
+                // 计数
+                if (pre == null || cur.val != pre.val) {
+                    count = 1;
+                }else {
+                    count++;
+                }
+                // 更新结果
+                if (count > maxCount) {
+                    maxCount = count;
+                    result.clear();
+                    result.add(cur.val);
+                }else if (count == maxCount) {
+                    result.add(cur.val);
+                }
+                pre = cur;
+                cur = cur.right;
+            }
+        }
+        return result.stream().mapToInt(Integer::intValue).toArray();
+    }
+}
+```
 
 ## Python 
 

problems/0530.二叉搜索树的最小绝对差.md

@@ -171,7 +171,34 @@ class Solution {
     }
 }
 ```
+迭代法-中序遍历
 
+```java
+class Solution {
+    TreeNode pre;
+    Stack<TreeNode> stack;
+    public int getMinimumDifference(TreeNode root) {
+        if (root == null) return 0;
+        stack = new Stack<>();
+        TreeNode cur = root;
+        int result = Integer.MAX_VALUE;
+        while (cur != null || !stack.isEmpty()) {
+            if (cur != null) {
+                stack.push(cur); // 将访问的节点放进栈
+                cur = cur.left; // 左
+            }else {
+                cur = stack.pop(); 
+                if (pre != null) { // 中
+                    result = Math.min(result, cur.val - pre.val);
+                }
+                pre = cur;
+                cur = cur.right; // 右
+            }
+        }
+        return result;
+    }
+}
+```
 ## Python 
 
 递归