添加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;
+        if(cur.right != null){
+            if(cur.next != null) cur.right.next = cur.next.left;
+            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