feat: add solutions to lc problem: No.0116

No.0116.Populating Next Right Pointers in Each Node

Author: yanglbme

solution/0100-0199/0116.Populating Next Right Pointers in Each Node/README.md

@@ -63,7 +63,19 @@ struct Node {
 
 <!-- 这里可写通用的实现逻辑 -->
 
-“BFS 层次遍历”实现。
+**方法一：BFS**
+
+使用队列进行层序遍历，每次遍历一层时，将当前层的节点按顺序连接起来。
+
+时间复杂度 $O(n)$，空间复杂度 $O(n)$。其中 $n$ 为二叉树的节点个数。
+
+**方法二：DFS**
+
+使用递归进行前序遍历，每次遍历到一个节点时，将其左右子节点按顺序连接起来。
+
+具体地，我们设计一个函数 $dfs(left, right)$，表示将 $left$ 节点的 $next$ 指针指向 $right$ 节点。在函数中，我们首先判断 $left$ 和 $right$ 是否为空，若都不为空，则将 $left.next$ 指向 $right$，然后递归地调用 $dfs(left.left, left.right)$, $dfs(left.right, right.left)$, $dfs(right.left, right.right)$。
+
+时间复杂度 $O(n)$，空间复杂度 $O(n)$。其中 $n$ 为二叉树的节点个数。
 
 <!-- tabs:start -->
 
@@ -84,21 +96,47 @@ class Node:
 
 
 class Solution:
-    def connect(self, root: 'Node') -> 'Node':
-        if root is None or (root.left is None and root.right is None):
+    def connect(self, root: "Optional[Node]") -> "Optional[Node]":
+        if root is None:
             return root
         q = deque([root])
         while q:
-            size = len(q)
-            cur = None
-            for _ in range(size):
+            p = None
+            for _ in range(len(q)):
                 node = q.popleft()
-                if node.right:
-                    q.append(node.right)
+                if p:
+                    p.next = node
+                p = node
                 if node.left:
                     q.append(node.left)
-                node.next = cur
-                cur = node
+                if node.right:
+                    q.append(node.right)
+        return root
+```
+
+```python
+"""
+# Definition for a Node.
+class Node:
+    def __init__(self, val: int = 0, left: 'Node' = None, right: 'Node' = None, next: 'Node' = None):
+        self.val = val
+        self.left = left
+        self.right = right
+        self.next = next
+"""
+
+class Solution:
+    def connect(self, root: 'Optional[Node]') -> 'Optional[Node]':
+        def dfs(left, right):
+            if left is None or right is None:
+                return
+            left.next = right
+            dfs(left.left, left.right)
+            dfs(left.right, right.left)
+            dfs(right.left, right.right)
+
+        if root:
+            dfs(root.left, root.right)
         return root
 ```
 
@@ -132,30 +170,76 @@ class Node {
 
 class Solution {
     public Node connect(Node root) {
-        if (root == null || (root.left == null && root.right == null)) {
+        if (root == null) {
             return root;
         }
         Deque<Node> q = new ArrayDeque<>();
         q.offer(root);
         while (!q.isEmpty()) {
-            Node cur = null;
-            for (int i = 0, n = q.size(); i < n; ++i) {
-                Node node = q.pollFirst();
-                if (node.right != null) {
-                    q.offer(node.right);
+            Node p = null;
+            for (int n = q.size(); n > 0; --n) {
+                Node node = q.poll();
+                if (p != null) {
+                    p.next = node;
                 }
+                p = node;
                 if (node.left != null) {
                     q.offer(node.left);
                 }
-                node.next = cur;
-                cur = node;
+                if (node.right != null) {
+                    q.offer(node.right);
+                }
             }
         }
         return root;
     }
 }
 ```
 
+```java
+/*
+// Definition for a Node.
+class Node {
+    public int val;
+    public Node left;
+    public Node right;
+    public Node next;
+
+    public Node() {}
+
+    public Node(int _val) {
+        val = _val;
+    }
+
+    public Node(int _val, Node _left, Node _right, Node _next) {
+        val = _val;
+        left = _left;
+        right = _right;
+        next = _next;
+    }
+};
+*/
+
+class Solution {
+    public Node connect(Node root) {
+        if (root != null) {
+            dfs(root.left, root.right);
+        }
+        return root;
+    }
+
+    private void dfs(Node left, Node right) {
+        if (left == null || right == null) {
+            return;
+        }
+        left.next = right;
+        dfs(left.left, left.right);
+        dfs(left.right, right.left);
+        dfs(right.left, right.right);
+    }
+}
+```
+
 ### **C++**
 
 ```cpp
@@ -180,31 +264,139 @@ public:
 class Solution {
 public:
     Node* connect(Node* root) {
-        if (!root || (!root->left && !root->right)) {
+        if (!root) {
             return root;
         }
-        queue<Node*> q;
-        q.push(root);
+        queue<Node*> q{{root}};
         while (!q.empty()) {
-            Node* cur = nullptr;
-            for (int i = 0, n = q.size(); i < n; ++i) {
+            Node* p = nullptr;
+            for (int n = q.size(); n; --n) {
                 Node* node = q.front();
                 q.pop();
-                if (node->right) {
-                    q.push(node->right);
+                if (p) {
+                    p->next = node;
                 }
+                p = node;
                 if (node->left) {
                     q.push(node->left);
                 }
-                node->next = cur;
-                cur = node;
+                if (node->right) {
+                    q.push(node->right);
+                }
             }
         }
         return root;
     }
 };
 ```
 
+```cpp
+/*
+// Definition for a Node.
+class Node {
+public:
+    int val;
+    Node* left;
+    Node* right;
+    Node* next;
+
+    Node() : val(0), left(NULL), right(NULL), next(NULL) {}
+
+    Node(int _val) : val(_val), left(NULL), right(NULL), next(NULL) {}
+
+    Node(int _val, Node* _left, Node* _right, Node* _next)
+        : val(_val), left(_left), right(_right), next(_next) {}
+};
+*/
+
+class Solution {
+public:
+    Node* connect(Node* root) {
+        function<void(Node*, Node*)> dfs = [&](Node* left, Node* right) {
+            if (!left || !right) {
+                return;
+            }
+            left->next = right;
+            dfs(left->left, left->right);
+            dfs(left->right, right->left);
+            dfs(right->left, right->right);
+        };
+        if (root) {
+            dfs(root->left, root->right);
+        }
+        return root;
+    }
+};
+```
+
+### **Go**
+
+```go
+/**
+ * Definition for a Node.
+ * type Node struct {
+ *     Val int
+ *     Left *Node
+ *     Right *Node
+ *     Next *Node
+ * }
+ */
+
+func connect(root *Node) *Node {
+	if root == nil {
+		return root
+	}
+	q := []*Node{root}
+	for len(q) > 0 {
+		var p *Node
+		for n := len(q); n > 0; n-- {
+			node := q[0]
+			q = q[1:]
+			if p != nil {
+				p.Next = node
+			}
+			p = node
+			if node.Left != nil {
+				q = append(q, node.Left)
+			}
+			if node.Right != nil {
+				q = append(q, node.Right)
+			}
+		}
+	}
+	return root
+}
+```
+
+```go
+/**
+ * Definition for a Node.
+ * type Node struct {
+ *     Val int
+ *     Left *Node
+ *     Right *Node
+ *     Next *Node
+ * }
+ */
+
+func connect(root *Node) *Node {
+	var dfs func(*Node, *Node)
+	dfs = func(left, right *Node) {
+		if left == nil || right == nil {
+			return
+		}
+		left.Next = right
+		dfs(left.Left, left.Right)
+		dfs(left.Right, right.Left)
+		dfs(right.Left, right.Right)
+	}
+	if root != nil {
+		dfs(root.Left, root.Right)
+	}
+	return root
+}
+```
+
 ### **TypeScript**
 
 ```ts
@@ -276,38 +468,6 @@ function connect(root: Node | null): Node | null {
 }
 ```
 
-### **Go**
-
-```go
-/**
- * Definition for a Node.
- * type Node struct {
- *     Val int
- *     Left *Node
- *     Right *Node
- *     Next *Node
- * }
- */
-
-func connect(root *Node) *Node {
-	if root == nil {
-		return root
-	}
-	traversal(root.Left, root.Right)
-	return root
-}
-
-func traversal(left, right *Node) {
-	if left == nil || right == nil {
-		return
-	}
-	left.Next = right
-	traversal(left.Left, left.Right)
-	traversal(left.Right, right.Left)
-	traversal(right.Left, right.Right)
-}
-```
-
 ### **...**
 
 ```