Merge pull request #588 from ironartisan/master

添加0116.填充每个节点的下一个右侧节点指针java和python3版本

problems/0116.填充每个节点的下一个右侧节点指针.md

@@ -130,15 +130,97 @@ public:
 ## Java
 
 ```java
-
+// 递归法
+class Solution {
+    public void traversal(Node cur) {
+        if (cur == null) return;
+        if (cur.left != null) cur.left.next = cur.right; // 操作1
+        if (cur.right != null) {
+            if(cur.next != null) cur.right.next = cur.next.left; //操作2
+            else cur.right.next = null;
+        }
+        traversal(cur.left);  // 左
+        traversal(cur.right); //右
+    }
+    public Node connect(Node root) {
+        traversal(root);
+        return root;
+    }
+}
+```
+```java
+// 迭代法
+class Solution {
+    public Node connect(Node root) {
+        if (root == null) return root;
+        Queue<Node> que = new LinkedList<Node>();
+        que.offer(root);
+        Node nodePre = null;
+        Node node = null;
+        while (!que.isEmpty()) {
+            int size = que.size();
+            for (int i=0; i<size; i++) { // 开始每一层的遍历
+                if (i == 0) {
+                    nodePre = que.peek(); // 记录一层的头结点
+                    que.poll();
+                    node = nodePre;
+                } else {
+                    node = que.peek();
+                    que.poll();
+                    nodePre.next = node; // 本层前一个节点next指向本节点
+                    nodePre = nodePre.next; 
+                }
+                if (node.left != null) que.offer(node.left);
+                if (node.right != null) que.offer(node.right);
+            }
+            nodePre.next = null; // 本层最后一个节点指向null
+        }
+        return root;
+    }
+}
 ```
 
 ## Python
 
 ```python
-
+# 递归法
+class Solution:
+    def connect(self, root: 'Node') -> 'Node':
+        def traversal(cur: 'Node') -> 'Node':
+            if not cur: return []
+            if cur.left: cur.left.next = cur.right # 操作1
+            if cur.right:
+                if cur.next:
+                    cur.right.next = cur.next.left # 操作2
+                else:
+                    cur.right.next = None
+            traversal(cur.left) # 左
+            traversal(cur.right) # 右
+        traversal(root)
+        return root
+```
+```python
+# 迭代法
+class Solution:
+    def connect(self, root: 'Node') -> 'Node':
+        if not root: return 
+        res = []
+        queue = [root]
+        while queue:
+            size = len(queue)
+            for i in range(size): # 开始每一层的遍历
+                if i==0: 
+                    nodePre = queue.pop(0) # 记录一层的头结点
+                    node = nodePre
+                else:
+                    node = queue.pop(0)
+                    nodePre.next = node # 本层前一个节点next指向本节点
+                    nodePre = nodePre.next
+                if node.left: queue.append(node.left)
+                if node.right: queue.append(node.right)
+            nodePre.next = None # 本层最后一个节点指向None
+        return root
 ```
-
 ## Go
 
 ```go

problems/0925.长按键入.md

@@ -8,7 +8,7 @@
 <p align="center"><strong>欢迎大家<a href="https://mp.weixin.qq.com/s/tqCxrMEU-ajQumL1i8im9A">参与本项目</a>，贡献其他语言版本的代码，拥抱开源，让更多学习算法的小伙伴们收益！</strong></p>
 
 # 925.长按键入
-
+题目链接：https://leetcode-cn.com/problems/long-pressed-name/
 你的朋友正在使用键盘输入他的名字 name。偶尔，在键入字符 c 时，按键可能会被长按，而字符可能被输入 1 次或多次。
 
 你将会检查键盘输入的字符 typed。如果它对应的可能是你的朋友的名字（其中一些字符可能被长按），那么就返回 True。
@@ -100,7 +100,31 @@ public:
 Java：
 
 Python：
-
+```python
+class Solution:
+    def isLongPressedName(self, name: str, typed: str) -> bool:
+        i, j = 0, 0
+        m, n = len(name) , len(typed) 
+        while i< m and j < n:
+            if name[i] == typed[j]: # 相同时向后匹配
+                i += 1
+                j += 1
+            else: # 不相同
+                if j == 0: return False # 如果第一位不相同，直接返回false
+                # 判断边界为n-1,若为n会越界,例如name:"kikcxmvzi" typed:"kiikcxxmmvvzzz"
+                while j < n - 1  and typed[j] == typed[j-1]: j += 1
+                if name[i] == typed[j]:
+                    i += 1
+                    j += 1
+                else: return False
+        # 说明name没有匹配完
+        if i < m: return False
+        # 说明type没有匹配完
+        while j < n:
+            if typed[j] == typed[j-1]: j += 1
+            else: return False
+        return True
+```
 Go：
 
 JavaScript：

problems/1382.将二叉搜索树变平衡.md

@@ -55,7 +55,7 @@ private:
         vec.push_back(cur->val);
         traversal(cur->right);
     }
-    有序数组转平衡二叉树
+    // 有序数组转平衡二叉树
     TreeNode* getTree(vector<int>& nums, int left, int right) {
         if (left > right) return nullptr;
         int mid = left + ((right - left) / 2);
@@ -76,9 +76,53 @@ public:
 # 其他语言版本
 
 Java：
-
+```java
+class Solution {
+    ArrayList <Integer> res = new ArrayList<Integer>();
+    // 有序树转成有序数组
+    private void travesal(TreeNode cur) {
+            if (cur == null) return;
+            travesal(cur.left);
+            res.add(cur.val);
+            travesal(cur.right);
+        }
+    // 有序数组转成平衡二叉树
+    private TreeNode getTree(ArrayList <Integer> nums, int left, int right) {
+        if (left > right) return null;
+        int mid = left + (right - left) / 2;
+        TreeNode root = new TreeNode(nums.get(mid));
+        root.left = getTree(nums, left, mid - 1);
+        root.right = getTree(nums, mid + 1, right);
+        return root;
+    }
+    public TreeNode balanceBST(TreeNode root) {
+        travesal(root);
+        return getTree(res, 0, res.size() - 1);
+    }
+}
+```
 Python：
-
+```python
+class Solution:
+    def balanceBST(self, root: TreeNode) -> TreeNode:
+        res = []
+        # 有序树转成有序数组
+        def traversal(cur: TreeNode):
+            if not cur: return
+            traversal(cur.left)
+            res.append(cur.val)
+            traversal(cur.right)
+        # 有序数组转成平衡二叉树
+        def getTree(nums: List, left, right):
+            if left > right: return 
+            mid = left + (right -left) // 2
+            root = TreeNode(nums[mid])
+            root.left = getTree(nums, left, mid - 1)
+            root.right = getTree(nums, mid + 1, right)
+            return root
+        traversal(root)
+        return getTree(res, 0, len(res) - 1)
+```
 Go：
 
 JavaScript：