LeetCode 145. Binary Tree Postorder Traversal

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

题目:

Given a binary tree, return the postorder traversal of its nodes' values.

For example:
Given binary tree {1,#,2,3}

   1
    \
     2
    /
   3

return [3,2,1].

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

题解:

类似Binary Tree Inorder Traversal 和 Binary Tree Preorder Traversal.

Method 1:  Recursion

Time Complexity: O(n). Space: O(logn).

AC Java:

 1 /**
 2  * Definition for a binary tree node.
 3  * public class TreeNode {
 4  *     int val;
 5  *     TreeNode left;
 6  *     TreeNode right;
 7  *     TreeNode(int x) { val = x; }
 8  * }
 9  */
10 public class Solution {
11     //Method 1: Recursion
12     public List<Integer> postorderTraversal(TreeNode root) {
13         //Recursion
14         List<Integer> ls = new ArrayList<Integer>();
15         helper(root,ls);
16         
17         return ls;
18     }
19     private void helper(TreeNode root,List<Integer> ls){
20         if(root == null){
21             return;
22         }
23         helper(root.left,ls);
24         helper(root.right,ls);
25         ls.add(root.val);
26     }
27 }

AC C++:

 1 /**
 2  * Definition for a binary tree node.
 3  * struct TreeNode {
 4  *     int val;
 5  *     TreeNode *left;
 6  *     TreeNode *right;
 7  *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 8  *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 9  *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
10  * };
11  */
12 class Solution {
13 public:
14     vector<int> postorderTraversal(TreeNode* root) {
15         vector<int> res;
16         dfs(root, res);
17         return res;
18     }
19 
20 private:
21     void dfs(TreeNode* root, vector<int>& res){
22         if(!root){
23             return;
24         }
25 
26         dfs(root->left, res);
27         dfs(root->right, res);
28         res.push_back(root->val);
29     }
30 };

AC Python:

 1 # Definition for a binary tree node.
 2 # class TreeNode:
 3 #     def __init__(self, val=0, left=None, right=None):
 4 #         self.val = val
 5 #         self.left = left
 6 #         self.right = right
 7 class Solution:
 8     def postorderTraversal(self, root: Optional[TreeNode]) -> List[int]:
 9         res = []
10         self.dfs(root, res)
11         return res
12     def dfs(self, root, res):
13         if not root:
14             return
15         self.dfs(root.left, res)
16         self.dfs(root.right, res)
17         res.append(root.val)

Method 2: 

Pretty much like method 2 of Binary Tree Preorder Traversal.

The difference is that when pushing into stack, push from left to right.

Time Complexity: O(n).

Space: O(logn).

AC Java:

 1 /**
 2  * Definition for a binary tree node.
 3  * public class TreeNode {
 4  *     int val;
 5  *     TreeNode left;
 6  *     TreeNode right;
 7  *     TreeNode(int x) { val = x; }
 8  * }
 9  */
10 class Solution {
11     public List<Integer> postorderTraversal(TreeNode root) {
12         List<Integer> res = new ArrayList<>();
13         if(root == null){
14             return res;
15         }
16         
17         Stack<TreeNode> stk = new Stack<>();
18         stk.push(root);
19         while(!stk.isEmpty()){
20             TreeNode cur = stk.pop();
21             res.add(cur.val);
22             if(cur.left != null){
23                 stk.push(cur.left);
24             }
25             
26             if(cur.right != null){
27                 stk.push(cur.right);
28             }
29         }
30         
31         Collections.reverse(res);
32         return res;
33     }
34 }

Method 3: Iteration + Stack

和Preorder, Inorder 类似.

当栈顶点右侧为空 或者 右侧已经traverse 过了, 就可以把栈顶的点加入res中. 节点pre用来记载刚刚加入res的点, 可以用来判定右侧是否已经traverse过了.

top.right == pre 说明right已经加入res里了.

Time Complexity: O(n), 每个点访问了一次. Space:O(logn).

AC Java:

 1 /**
 2  * Definition for a binary tree node.
 3  * public class TreeNode {
 4  *     int val;
 5  *     TreeNode left;
 6  *     TreeNode right;
 7  *     TreeNode(int x) { val = x; }
 8  * }
 9  */
10 class Solution {
11     public List<Integer> postorderTraversal(TreeNode root) {
12         List<Integer> res = new ArrayList<Integer>();
13         Stack<TreeNode> stk = new Stack<TreeNode>();
14         TreeNode pre = null;
15         while(root != null || !stk.isEmpty()){
16             if(root != null){
17                 stk.push(root);
18                 root = root.left;
19             }else{
20                 TreeNode top = stk.peek();
21                 if(top.right == null || top.right == pre){
22                     res.add(top.val);
23                     stk.pop();
24                     pre = top;
25                 }else{
26                     root = top.right;
27                 }
28             }
29         }
30         return res;
31     }
32 }

AC C++:

 1 /**
 2  * Definition for a binary tree node.
 3  * struct TreeNode {
 4  *     int val;
 5  *     TreeNode *left;
 6  *     TreeNode *right;
 7  *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 8  *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 9  *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
10  * };
11  */
12 class Solution {
13 public:
14     vector<int> postorderTraversal(TreeNode* root) {
15         vector<int> res;
16         stack<TreeNode*> stk;
17         TreeNode* pre;
18         while(root || !stk.empty()){
19             if(root){
20                 stk.push(root);
21                 root = root->left;
22             }else{
23                 TreeNode* top = stk.top();
24                 if(!top->right || top->right == pre){
25                     res.push_back(top->val);
26                     stk.pop();
27                     pre = top;
28                 }else{
29                     root = top->right;
30                 }
31             }
32         }
33 
34         return res;
35     }
36 };

AC Python:

 1 # Definition for a binary tree node.
 2 # class TreeNode:
 3 #     def __init__(self, val=0, left=None, right=None):
 4 #         self.val = val
 5 #         self.left = left
 6 #         self.right = right
 7 class Solution:
 8     def postorderTraversal(self, root: Optional[TreeNode]) -> List[int]:
 9         res, stk = [], []
10         pre = None
11         while root or stk:
12             if root:
13                 stk.append(root)
14                 root = root.left
15             else:
16                 top = stk[-1]
17                 if not top.right or top.right == pre:
18                     res.append(top.val)
19                     pre = top
20                     stk.pop()
21                 else:
22                     root = top.right
23         return res

跟上Binary Tree Preorder Traversal.

posted @ 2015-08-20 08:01  Dylan_Java_NYC  阅读(329)  评论(0编辑  收藏  举报