feat: add solutions to lc problem: No.0590 (doocs#2354)

No.0590.N-ary Tree Postorder Traversal

Author: yanglbme

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

@@ -369,10 +369,9 @@ public:
  * }
  */
 
-func preorder(root *Node) []int {
-	var ans []int
+func preorder(root *Node) (ans []int) {
 	if root == nil {
-		return ans
+		return
 	}
 	stk := []*Node{root}
 	for len(stk) > 0 {
@@ -384,7 +383,7 @@ func preorder(root *Node) []int {
 			stk = append(stk, children[i])
 		}
 	}
-	return ans
+	return
 }
 ```
 

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

@@ -365,10 +365,9 @@ public:
  * }
  */
 
-func preorder(root *Node) []int {
-	var ans []int
+func preorder(root *Node) (ans []int) {
 	if root == nil {
-		return ans
+		return
 	}
 	stk := []*Node{root}
 	for len(stk) > 0 {
@@ -380,7 +379,7 @@ func preorder(root *Node) []int {
 			stk = append(stk, children[i])
 		}
 	}
-	return ans
+	return
 }
 ```
 

solution/0500-0599/0589.N-ary Tree Preorder Traversal/Solution2.go

@@ -6,10 +6,9 @@
  * }
  */
 
-func preorder(root *Node) []int {
-	var ans []int
+func preorder(root *Node) (ans []int) {
 	if root == nil {
-		return ans
+		return
 	}
 	stk := []*Node{root}
 	for len(stk) > 0 {
@@ -21,5 +20,5 @@ func preorder(root *Node) []int {
 			stk = append(stk, children[i])
 		}
 	}
-	return ans
+	return
 }

solution/0500-0599/0590.N-ary Tree Postorder Traversal/README.md

@@ -46,7 +46,11 @@
 
 ## 解法
 
-### 方法一
+### 方法一：递归
+
+我们可以递归地遍历整棵树。对于每个节点，先对该节点的每个子节点递归地调用函数，然后将节点的值加入答案。
+
+时间复杂度 $O(n)$，空间复杂度 $O(n)$。其中 $n$ 为节点数。
 
 <!-- tabs:start -->
 
@@ -95,11 +99,9 @@ class Node {
 */
 
 class Solution {
-
-    private List<Integer> ans;
+    private List<Integer> ans = new ArrayList<>();
 
     public List<Integer> postorder(Node root) {
-        ans = new ArrayList<>();
         dfs(root);
         return ans;
     }
@@ -141,15 +143,18 @@ class Solution {
 public:
     vector<int> postorder(Node* root) {
         vector<int> ans;
-        dfs(root, ans);
+        function<void(Node*)> dfs = [&](Node* root) {
+            if (!root) {
+                return;
+            }
+            for (auto& child : root->children) {
+                dfs(child);
+            }
+            ans.push_back(root->val);
+        };
+        dfs(root);
         return ans;
     }
-
-    void dfs(Node* root, vector<int>& ans) {
-        if (!root) return;
-        for (auto& child : root->children) dfs(child, ans);
-        ans.push_back(root->val);
-    }
 };
 ```
 
@@ -162,9 +167,8 @@ public:
  * }
  */
 
-func postorder(root *Node) []int {
-	var ans []int
-	var dfs func(root *Node)
+func postorder(root *Node) (ans []int) {
+	var dfs func(*Node)
 	dfs = func(root *Node) {
 		if root == nil {
 			return
@@ -175,7 +179,7 @@ func postorder(root *Node) []int {
 		ans = append(ans, root.Val)
 	}
 	dfs(root)
-	return ans
+	return
 }
 ```
 
@@ -193,24 +197,30 @@ func postorder(root *Node) []int {
  */
 
 function postorder(root: Node | null): number[] {
-    const res = [];
+    const ans: number[] = [];
     const dfs = (root: Node | null) => {
-        if (root == null) {
+        if (!root) {
             return;
         }
-        for (const node of root.children) {
-            dfs(node);
+        for (const child of root.children) {
+            dfs(child);
         }
-        res.push(root.val);
+        ans.push(root.val);
     };
     dfs(root);
-    return res;
+    return ans;
 }
 ```
 
 <!-- tabs:end -->
 
-### 方法二
+### 方法二：迭代（栈实现）
+
+我们也可以用迭代的方法来解决这个问题。
+
+我们使用一个栈来帮助我们得到后序遍历，我们首先把根节点入栈，因为后序遍历是左子树、右子树、根节点，栈的特点是先进后出，所以我们先把节点的值加入答案，然后对该节点的每个子节点按照从左到右的顺序依次入栈，这样可以得到根节点、右子树、左子树的遍历结果。最后把答案反转即可得到后序遍历的结果。
+
+时间复杂度 $O(n)$，空间复杂度 $O(n)$。其中 $n$ 为节点数。
 
 <!-- tabs:start -->
 
@@ -303,13 +313,17 @@ class Solution {
 public:
     vector<int> postorder(Node* root) {
         vector<int> ans;
-        if (!root) return ans;
+        if (!root) {
+            return ans;
+        }
         stack<Node*> stk{{root}};
         while (!stk.empty()) {
             root = stk.top();
             ans.push_back(root->val);
             stk.pop();
-            for (Node* child : root->children) stk.push(child);
+            for (Node* child : root->children) {
+                stk.push(child);
+            }
         }
         reverse(ans.begin(), ans.end());
         return ans;
@@ -358,23 +372,17 @@ func postorder(root *Node) []int {
  */
 
 function postorder(root: Node | null): number[] {
-    const res = [];
-    if (root == null) {
-        return res;
+    const ans: number[] = [];
+    if (!root) {
+        return ans;
     }
-    const stack = [root];
-    while (stack.length !== 0) {
-        const target = stack[stack.length - 1];
-        if (target.children == null) {
-            res.push(stack.pop().val);
-        } else {
-            for (let i = target.children.length - 1; i >= 0; i--) {
-                stack.push(target.children[i]);
-            }
-            target.children = null;
-        }
+    const stk: Node[] = [root];
+    while (stk.length) {
+        const { val, children } = stk.pop()!;
+        ans.push(val);
+        stk.push(...children);
     }
-    return res;
+    return ans.reverse();
 }
 ```
 

solution/0500-0599/0590.N-ary Tree Postorder Traversal/README_EN.md

@@ -37,7 +37,11 @@
 
 ## Solutions
 
-### Solution 1
+### Solution 1: Recursion
+
+We can recursively traverse the entire tree. For each node, we first recursively call the function for each of the node's children, then add the node's value to the answer.
+
+The time complexity is $O(n)$, and the space complexity is $O(n)$. Here, $n$ is the number of nodes.
 
 <!-- tabs:start -->
 
@@ -86,11 +90,9 @@ class Node {
 */
 
 class Solution {
-
-    private List<Integer> ans;
+    private List<Integer> ans = new ArrayList<>();
 
     public List<Integer> postorder(Node root) {
-        ans = new ArrayList<>();
         dfs(root);
         return ans;
     }
@@ -132,15 +134,18 @@ class Solution {
 public:
     vector<int> postorder(Node* root) {
         vector<int> ans;
-        dfs(root, ans);
+        function<void(Node*)> dfs = [&](Node* root) {
+            if (!root) {
+                return;
+            }
+            for (auto& child : root->children) {
+                dfs(child);
+            }
+            ans.push_back(root->val);
+        };
+        dfs(root);
         return ans;
     }
-
-    void dfs(Node* root, vector<int>& ans) {
-        if (!root) return;
-        for (auto& child : root->children) dfs(child, ans);
-        ans.push_back(root->val);
-    }
 };
 ```
 
@@ -153,9 +158,8 @@ public:
  * }
  */
 
-func postorder(root *Node) []int {
-	var ans []int
-	var dfs func(root *Node)
+func postorder(root *Node) (ans []int) {
+	var dfs func(*Node)
 	dfs = func(root *Node) {
 		if root == nil {
 			return
@@ -166,7 +170,7 @@ func postorder(root *Node) []int {
 		ans = append(ans, root.Val)
 	}
 	dfs(root)
-	return ans
+	return
 }
 ```
 
@@ -184,24 +188,30 @@ func postorder(root *Node) []int {
  */
 
 function postorder(root: Node | null): number[] {
-    const res = [];
+    const ans: number[] = [];
     const dfs = (root: Node | null) => {
-        if (root == null) {
+        if (!root) {
             return;
         }
-        for (const node of root.children) {
-            dfs(node);
+        for (const child of root.children) {
+            dfs(child);
         }
-        res.push(root.val);
+        ans.push(root.val);
     };
     dfs(root);
-    return res;
+    return ans;
 }
 ```
 
 <!-- tabs:end -->
 
-### Solution 2
+### Solution 2: Iteration (Stack Implementation)
+
+We can also solve this problem iteratively.
+
+We use a stack to help us get the post-order traversal. We first push the root node into the stack. Since the post-order traversal is left subtree, right subtree, root, and the characteristic of the stack is first in last out, we first add the node's value to the answer, then push each of the node's children into the stack in the order from left to right. This way, we can get the traversal result of root, right subtree, left subtree. Finally, we reverse the answer to get the post-order traversal result.
+
+The time complexity is $O(n)$, and the space complexity is $O(n)$. Here, $n$ is the number of nodes.
 
 <!-- tabs:start -->
 
@@ -294,13 +304,17 @@ class Solution {
 public:
     vector<int> postorder(Node* root) {
         vector<int> ans;
-        if (!root) return ans;
+        if (!root) {
+            return ans;
+        }
         stack<Node*> stk{{root}};
         while (!stk.empty()) {
             root = stk.top();
             ans.push_back(root->val);
             stk.pop();
-            for (Node* child : root->children) stk.push(child);
+            for (Node* child : root->children) {
+                stk.push(child);
+            }
         }
         reverse(ans.begin(), ans.end());
         return ans;
@@ -349,23 +363,17 @@ func postorder(root *Node) []int {
  */
 
 function postorder(root: Node | null): number[] {
-    const res = [];
-    if (root == null) {
-        return res;
+    const ans: number[] = [];
+    if (!root) {
+        return ans;
     }
-    const stack = [root];
-    while (stack.length !== 0) {
-        const target = stack[stack.length - 1];
-        if (target.children == null) {
-            res.push(stack.pop().val);
-        } else {
-            for (let i = target.children.length - 1; i >= 0; i--) {
-                stack.push(target.children[i]);
-            }
-            target.children = null;
-        }
+    const stk: Node[] = [root];
+    while (stk.length) {
+        const { val, children } = stk.pop()!;
+        ans.push(val);
+        stk.push(...children);
     }
-    return res;
+    return ans.reverse();
 }
 ```