feat: add solutions to lc problem: No.0589 (doocs#2347)

No.0589.N-ary Tree Preorder Traversal

Author: yanglbme

solution/0500-0599/0589.N-ary Tree Preorder Traversal/README.md

@@ -45,7 +45,11 @@
 
 ## 解法
 
-### 方法一
+### 方法一：递归
+
+我们可以递归地遍历整棵树。对于每个节点，先将节点的值加入答案，然后对该节点的每个子节点递归地调用函数。
+
+时间复杂度 $O(n)$，空间复杂度 $O(n)$。其中 $n$ 为节点数。
 
 <!-- tabs:start -->
 
@@ -60,16 +64,16 @@ class Node:
 
 
 class Solution:
-    def preorder(self, root: 'Node') -> List[int]:
+    def preorder(self, root: "Node") -> List[int]:
+        def dfs(root):
+            if root is None:
+                return
+            ans.append(root.val)
+            for child in root.children:
+                dfs(child)
+
         ans = []
-        if root is None:
-            return ans
-        stk = [root]
-        while stk:
-            node = stk.pop()
-            ans.append(node.val)
-            for child in node.children[::-1]:
-                stk.append(child)
+        dfs(root)
         return ans
 ```
 
@@ -94,22 +98,21 @@ class Node {
 */
 
 class Solution {
+    private List<Integer> ans = new ArrayList<>();
+
     public List<Integer> preorder(Node root) {
+        dfs(root);
+        return ans;
+    }
+
+    private void dfs(Node root) {
         if (root == null) {
-            return Collections.emptyList();
+            return;
         }
-        List<Integer> ans = new ArrayList<>();
-        Deque<Node> stk = new ArrayDeque<>();
-        stk.push(root);
-        while (!stk.isEmpty()) {
-            Node node = stk.pop();
-            ans.add(node.val);
-            List<Node> children = node.children;
-            for (int i = children.size() - 1; i >= 0; --i) {
-                stk.push(children.get(i));
-            }
+        ans.add(root.val);
+        for (Node child : root.children) {
+            dfs(child);
         }
-        return ans;
     }
 }
 ```
@@ -138,17 +141,17 @@ public:
 class Solution {
 public:
     vector<int> preorder(Node* root) {
-        if (!root) return {};
         vector<int> ans;
-        stack<Node*> stk;
-        stk.push(root);
-        while (!stk.empty()) {
-            Node* node = stk.top();
-            ans.push_back(node->val);
-            stk.pop();
-            auto children = node->children;
-            for (int i = children.size() - 1; i >= 0; --i) stk.push(children[i]);
-        }
+        function<void(Node*)> dfs = [&](Node* root) {
+            if (!root) {
+                return;
+            }
+            ans.push_back(root->val);
+            for (auto& child : root->children) {
+                dfs(child);
+            }
+        };
+        dfs(root);
         return ans;
     }
 };
@@ -163,22 +166,19 @@ public:
  * }
  */
 
-func preorder(root *Node) []int {
-	var ans []int
-	if root == nil {
-		return ans
-	}
-	stk := []*Node{root}
-	for len(stk) > 0 {
-		node := stk[len(stk)-1]
-		ans = append(ans, node.Val)
-		stk = stk[:len(stk)-1]
-		children := node.Children
-		for i := len(children) - 1; i >= 0; i-- {
-			stk = append(stk, children[i])
+func preorder(root *Node) (ans []int) {
+	var dfs func(*Node)
+	dfs = func(root *Node) {
+		if root == nil {
+			return
+		}
+		ans = append(ans, root.Val)
+		for _, child := range root.Children {
+			dfs(child)
 		}
 	}
-	return ans
+	dfs(root)
+	return
 }
 ```
 
@@ -196,20 +196,18 @@ func preorder(root *Node) []int {
  */
 
 function preorder(root: Node | null): number[] {
-    const res = [];
-    if (root == null) {
-        return res;
-    }
-    const stack = [root];
-    while (stack.length !== 0) {
-        const { val, children } = stack.pop();
-        res.push(val);
-        const n = children.length;
-        for (let i = n - 1; i >= 0; i--) {
-            stack.push(children[i]);
+    const ans: number[] = [];
+    const dfs = (root: Node | null) => {
+        if (!root) {
+            return;
         }
-    }
-    return res;
+        ans.push(root.val);
+        for (const child of root.children) {
+            dfs(child);
+        }
+    };
+    dfs(root);
+    return ans;
 }
 ```
 
@@ -247,10 +245,149 @@ int* preorder(struct Node* root, int* returnSize) {
 
 <!-- tabs:end -->
 
-### 方法二
+### 方法二：迭代（栈实现）
+
+我们也可以用迭代的方法来解决这个问题。
+
+我们使用一个栈来帮助我们得到前序遍历，我们首先把根节点入栈，因为前序遍历是根节点、左子树、右子树，栈的特点是先进后出，所以我们先把节点的值加入答案，然后对该节点的每个子节点按照从右到左的顺序依次入栈。循环直到栈为空。
+
+时间复杂度 $O(n)$，空间复杂度 $O(n)$。其中 $n$ 为节点数。
 
 <!-- tabs:start -->
 
+```python
+"""
+# Definition for a Node.
+class Node:
+    def __init__(self, val=None, children=None):
+        self.val = val
+        self.children = children
+"""
+
+
+class Solution:
+    def preorder(self, root: 'Node') -> List[int]:
+        ans = []
+        if root is None:
+            return ans
+        stk = [root]
+        while stk:
+            node = stk.pop()
+            ans.append(node.val)
+            for child in node.children[::-1]:
+                stk.append(child)
+        return ans
+```
+
+```java
+/*
+// Definition for a Node.
+class Node {
+    public int val;
+    public List<Node> children;
+
+    public Node() {}
+
+    public Node(int _val) {
+        val = _val;
+    }
+
+    public Node(int _val, List<Node> _children) {
+        val = _val;
+        children = _children;
+    }
+};
+*/
+
+class Solution {
+    public List<Integer> preorder(Node root) {
+        if (root == null) {
+            return Collections.emptyList();
+        }
+        List<Integer> ans = new ArrayList<>();
+        Deque<Node> stk = new ArrayDeque<>();
+        stk.push(root);
+        while (!stk.isEmpty()) {
+            Node node = stk.pop();
+            ans.add(node.val);
+            List<Node> children = node.children;
+            for (int i = children.size() - 1; i >= 0; --i) {
+                stk.push(children.get(i));
+            }
+        }
+        return ans;
+    }
+}
+```
+
+```cpp
+/*
+// Definition for a Node.
+class Node {
+public:
+    int val;
+    vector<Node*> children;
+
+    Node() {}
+
+    Node(int _val) {
+        val = _val;
+    }
+
+    Node(int _val, vector<Node*> _children) {
+        val = _val;
+        children = _children;
+    }
+};
+*/
+
+class Solution {
+public:
+    vector<int> preorder(Node* root) {
+        if (!root) return {};
+        vector<int> ans;
+        stack<Node*> stk;
+        stk.push(root);
+        while (!stk.empty()) {
+            Node* node = stk.top();
+            ans.push_back(node->val);
+            stk.pop();
+            auto children = node->children;
+            for (int i = children.size() - 1; i >= 0; --i) stk.push(children[i]);
+        }
+        return ans;
+    }
+};
+```
+
+```go
+/**
+ * Definition for a Node.
+ * type Node struct {
+ *     Val int
+ *     Children []*Node
+ * }
+ */
+
+func preorder(root *Node) []int {
+	var ans []int
+	if root == nil {
+		return ans
+	}
+	stk := []*Node{root}
+	for len(stk) > 0 {
+		node := stk[len(stk)-1]
+		ans = append(ans, node.Val)
+		stk = stk[:len(stk)-1]
+		children := node.Children
+		for i := len(children) - 1; i >= 0; i-- {
+			stk = append(stk, children[i])
+		}
+	}
+	return ans
+}
+```
+
 ```ts
 /**
  * Definition for node.
@@ -265,17 +402,18 @@ int* preorder(struct Node* root, int* returnSize) {
  */
 
 function preorder(root: Node | null): number[] {
-    const ans = [];
-    const dfs = (root: Node | null) => {
-        if (root == null) {
-            return;
-        }
-        ans.push(root.val);
-        for (const node of root.children) {
-            dfs(node);
+    const ans: number[] = [];
+    if (!root) {
+        return ans;
+    }
+    const stk: Node[] = [root];
+    while (stk.length) {
+        const { val, children } = stk.pop()!;
+        ans.push(val);
+        for (let i = children.length - 1; i >= 0; i--) {
+            stk.push(children[i]);
         }
-    };
-    dfs(root);
+    }
     return ans;
 }
 ```