Leetcode 145. Binary Tree Postorder Traversal

遞歸

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    vector<int> postorderTraversal(TreeNode* root) {
        vector<int> ret;
        if (root != nullptr) {
            reSolver(root, ret);
        }
        return ret;
    }
private:
    void reSolver(TreeNode* root, vector<int>& ret) {
        if (root->left != nullptr) {
            reSolver(root->left, ret);
        }
        if (root->right != nullptr) {
            reSolver(root->right, ret);
        }
        ret.emplace_back(root->val);
        return;
    }
    
};

迭代

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    vector<int> postorderTraversal(TreeNode* root) {
        
        vector<int> ret;
        using TUPLE = tuple<TreeNode*, int>;
        stack<TUPLE> s;
        TreeNode* p = root;
        while (p != nullptr || !s.empty()) {
            if (p != nullptr) {
                s.push(make_tuple(p, 0));
                p = p->left;
            } else {
                auto& t = s.top();
                auto r = get<0>(t);
                if (get<1>(t) == 0) {
                    p = r->right;
                    ++get<1>(t);
                }else {
                    ret.emplace_back(r->val);
                    s.pop();
                }
            }
        }
        return ret;
    }
};

引入上一個node

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    vector<int> postorderTraversal(TreeNode* root) {
        
        vector<int> ret;

        stack<TreeNode*> s;
        TreeNode* p = root;
        TreeNode* lastp = nullptr;
        while (p != nullptr || !s.empty()) {
            
            if (p != nullptr) {
                s.push(p);
                lastp = p;
                p = p->left;
            } else {
                TreeNode* r = s.top();
                if (r->right != lastp) {
                    lastp = p;
                    p = r->right;
                } else {
                    ret.emplace_back(r->val);
                    s.pop();
                    lastp = r;
                    p = nullptr;
                }
            }
        }
        return ret;
    }
};

逆序

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    vector<int> postorderTraversal(TreeNode* root) {
        
        vector<int> tmp;

        stack<TreeNode*> s;
        TreeNode* p = root;
        TreeNode* lastp = nullptr;
        while (p != nullptr || !s.empty()) {
            
            if (p != nullptr) {
                tmp.emplace_back(p->val);
                s.push(p);
                p = p->right;
            } else {
                TreeNode* r = s.top();
                s.pop();
                p = r->left; 
            }
        }
        return vector<int>(rbegin(tmp), rend(tmp));
    }
};

145. Binary Tree Postorder Traversal