LeetCode 590. N-ary Tree Postorder Traversal

原题链接在这里：https://leetcode.com/problems/n-ary-tree-postorder-traversal/

题目：

Given the root of an n-ary tree, return the postorder traversal of its nodes' values.

Nary-Tree input serialization is represented in their level order traversal. Each group of children is separated by the null value (See examples)

Example 1:

Input: root = [1,null,3,2,4,null,5,6]
Output: [5,6,3,2,4,1]

Example 2:

Input: root = [1,null,2,3,4,5,null,null,6,7,null,8,null,9,10,null,null,11,null,12,null,13,null,null,14]
Output: [2,6,14,11,7,3,12,8,4,13,9,10,5,1]

Constraints:

  • The number of nodes in the tree is in the range [0, 104].
  • 0 <= Node.val <= 104
  • The height of the n-ary tree is less than or equal to 1000. 

Follow up: Recursive solution is trivial, could you do it iteratively?

题解：

Could do it recursively.

Time Complexity: O(n). n is the number of numbers in the tree.

Space: O(logn).

AC Java:

 1 /*
 2 // Definition for a Node.
 3 class Node {
 4     public int val;
 5     public List<Node> children;
 6 
 7     public Node() {}
 8 
 9     public Node(int _val) {
10         val = _val;
11     }
12 
13     public Node(int _val, List<Node> _children) {
14         val = _val;
15         children = _children;
16     }
17 };
18 */
19 
20 class Solution {
21     public List<Integer> postorder(Node root) {
22         List<Integer> res = new ArrayList<>();
23         if(root == null){
24             return res;
25         }
26         
27         dfs(root, res);
28         return res;
29     }
30     
31     private void dfs(Node root, List<Integer> res){
32         if(root == null){
33             return;
34         }
35         
36         for(Node next : root.children){
37             dfs(next, res);
38         }
39         
40         res.add(root.val);
41     }
42 }

AC C++:

 1 /*
 2 // Definition for a Node.
 3 class Node {
 4 public:
 5     int val;
 6     vector<Node*> children;
 7 
 8     Node() {}
 9 
10     Node(int _val) {
11         val = _val;
12     }
13 
14     Node(int _val, vector<Node*> _children) {
15         val = _val;
16         children = _children;
17     }
18 };
19 */
20 
21 class Solution {
22 public:
23     vector<int> postorder(Node* root) {
24         vector<int> res;
25         dfs(root, res);
26         return res;
27     }
28 
29 private:
30     void dfs(Node* root, vector<int>& res){
31         if(!root){
32             return;
33         }
34 
35         for(Node* child : root->children){
36             dfs(child, res);
37         }
38 
39         res.push_back(root->val);
40     }
41 };

Could do it iteratively. It is like method 2 in Binary Tree Postorder Traversal.

Time Complexity: O(n).

Space: O(logn). stack space.

AC Java:

 1 /*
 2 // Definition for a Node.
 3 class Node {
 4     public int val;
 5     public List<Node> children;
 6 
 7     public Node() {}
 8 
 9     public Node(int _val) {
10         val = _val;
11     }
12 
13     public Node(int _val, List<Node> _children) {
14         val = _val;
15         children = _children;
16     }
17 };
18 */
19 
20 class Solution {
21     public List<Integer> postorder(Node root) {
22         List<Integer> res = new ArrayList<>();
23         if(root == null){
24             return res;
25         }
26         
27         Stack<Node> stk = new Stack<>();
28         stk.push(root);
29         while(!stk.isEmpty()){
30             Node cur = stk.pop();
31             res.add(cur.val);
32             for(Node next : cur.children){
33                 if(next != null){
34                     stk.push(next);
35                 }
36             }
37         }
38         
39         Collections.reverse(res);
40         return res;
41     }
42 }

AC C++:

 1 /*
 2 // Definition for a Node.
 3 class Node {
 4 public:
 5     int val;
 6     vector<Node*> children;
 7 
 8     Node() {}
 9 
10     Node(int _val) {
11         val = _val;
12     }
13 
14     Node(int _val, vector<Node*> _children) {
15         val = _val;
16         children = _children;
17     }
18 };
19 */
20 
21 class Solution {
22 public:
23     vector<int> postorder(Node* root) {
24         vector<int> res;
25         if(!root){
26             return res;
27         }
28 
29         stack<Node*> stk;
30         stk.push(root);
31         while(!stk.empty()){
32             Node* cur = stk.top();
33             stk.pop();
34             res.push_back(cur->val);
35             for(Node* child : cur->children){
36                 stk.push(child);
37             }
38         }
39 
40         reverse(res.begin(), res.end());
41         return res;
42     }
43 };

类似N-ary Tree Preorder Traversal, Binary Tree Postorder Traversal.

posted @ 2022-06-27 05:42  Dylan_Java_NYC  阅读(26)  评论(0)  编辑  收藏  举报