LintCode: Binary Tree Postorder Traversal

 1 /**
 2  * Definition of TreeNode:
 3  * class TreeNode {
 4  * public:
 5  *     int val;
 6  *     TreeNode *left, *right;
 7  *     TreeNode(int val) {
 8  *         this->val = val;
 9  *         this->left = this->right = NULL;
10  *     }
11  * }
12  */
13 class Solution {
14     /**
15      * @param root: The root of binary tree.
16      * @return: Postorder in vector which contains node values.
17      */
18 public:
19     vector<int> postorderTraversal(TreeNode *root) {
20         // write your code here
21         vector<int> result;
22         if (root == NULL) {
23             return result;
24         }
25         if (root->left != NULL) {
26             vector<int> left = postorderTraversal(root->left);
27             result.reserve(result.size() + left.size());
28             result.insert(result.end(), left.begin(), left.end());
29         }
30         if (root->right != NULL) {
31             vector<int> right = postorderTraversal(root->right);
32             result.reserve(result.size() + right.size());
33             result.insert(result.end(), right.begin(), right.end());
34         }
35         result.push_back(root->val);
36         return result;
37     }
38 };

 1 /**
 2  * Definition of TreeNode:
 3  * class TreeNode {
 4  * public:
 5  *     int val;
 6  *     TreeNode *left, *right;
 7  *     TreeNode(int val) {
 8  *         this->val = val;
 9  *         this->left = this->right = NULL;
10  *     }
11  * }
12  */
13 class Solution {
14     /**
15      * @param root: The root of binary tree.
16      * @return: Postorder in vector which contains node values.
17      */
18 public:
19     vector<int> postorderTraversal(TreeNode *root) {
20         // write your code here
21         vector<int> result;
22         if (root == NULL) {
23             return result;
24         } else {
25             postorderCore(root, result);
26         }
27         return result;
28     }
29     void postorderCore(TreeNode *root, vector<int> &result) {
30         if (root == NULL) {
31             return;
32         }
33         if (root->left != NULL) {
34             postorderCore(root->left, result);
35         }
36         if (root->right != NULL) {
37             postorderCore(root->right, result);
38         }
39         result.push_back(root->val);
40         return;
41     } 
42 };

 1 /**
 2  * Definition of TreeNode:
 3  * class TreeNode {
 4  * public:
 5  *     int val;
 6  *     TreeNode *left, *right;
 7  *     TreeNode(int val) {
 8  *         this->val = val;
 9  *         this->left = this->right = NULL;
10  *     }
11  * }
12  */
13 class Solution {
14     /**
15      * @param root: The root of binary tree.
16      * @return: Postorder in vector which contains node values.
17      */
18 public:
19     vector<int> postorderTraversal(TreeNode *root) {
20         // write your code here
21         vector<int> result;
22         if (root == NULL) {
23             return result;
24         }
25         
26         TreeNode *cur = root, *pre = NULL;
27         stack<TreeNode *> sta;
28         
29         while (cur != NULL || !sta.empty()) {
30             while (cur != NULL) {
31                 sta.push(cur);
32                 cur = cur->left;
33             }
34             cur = sta.top();
35             if (cur->right == NULL || cur->right == pre) {
36                 sta.pop();
37                 result.push_back(cur->val);
38                 pre = cur;
39                 cur = NULL;
40             } else {
41                 cur = cur->right;
42             }
43         }
44         return result;
45     }
46 };