LeetCode--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?

題解：利用遞歸可輕易實現，要求用迭代，其實就是用自己寫的棧來實現遞歸，因爲DFS的遞歸實現本來就是用的棧。

DFS：

class Solution {
public:
    int dfs(TreeNode* now,vector<int>& ans){
        if(now == NULL)
            return 1;
        dfs(now->left,ans);
        dfs(now->right,ans);
        ans.push_back(now->val);
        return 1;
    }
    vector<int> postorderTraversal(TreeNode *root) {
        vector<int> ans;
        dfs(root,ans);
        return ans;
    }
};

迭代實現：

class Solution {
public:
    vector<int> postorderTraversal(TreeNode *root) {
        vector<int> ans;
        if(root == NULL)
            return ans;
        stack<TreeNode*> sta;
        TreeNode* tmp;
        TreeNode* pre = new TreeNode(0);
        //上一個退棧的點，不能賦值NULL
        sta.push(root);
        while(!sta.empty()){
            tmp = sta.top();
            //模仿DFS，只可能有三種情況進入這，就是要加入左節點，要加入右節點，此節點退棧
            if(pre != tmp->left&&pre != tmp->right&&tmp->left != NULL){
                //當上一個退棧的點不是左節點也不是右節點，則需要加入左節點
                sta.push(tmp->left);
            }
            else if(pre != tmp->right&&tmp->right != NULL){
                //當上一個退棧的點不是右節點，則加入右節點
                sta.push(tmp->right);
            }
            else{
                //此節點退棧
                sta.pop();
                ans.push_back(tmp->val);
                pre = tmp;
            }
        }
        return ans;
    }
};

更好的方法是，因爲最多第三次遍歷某個節點，當第一次到這個節點時，我們要進入它的左節點並且把它的左節點置爲NULL，下次到這個節點時就會直接檢查右節點。當兩個子節點都爲空時，pop出此節點並打印val。

代碼如下：

class Solution {
public:
    vector<int> postorderTraversal(TreeNode* root) {
        vector<int> ans;
        if(root == NULL) return ans;
        TreeNode* now;
        stack<TreeNode*> s;
        s.push(root);
        while(!s.empty()) {
            now = s.top();
            if(now->left) {
                s.push(now->left);
                now->left = NULL;
            }
            else if(now->right) {
                s.push(now->right);
                now->right = NULL;
            }
            else {
                ans.push_back(now->val);
                s.pop();
            }
        }
        return ans;
    }
};

Binary Tree Inorder Traversal 代碼如下：

class Solution {
public:
    vector<int> inorderTraversal(TreeNode* root) {
        vector<int> ans;
        if(root == NULL) return ans;
        stack<TreeNode*> s;
        s.push(root);
        while(!s.empty()) {
            TreeNode* now = s.top();
            if(now->left) {
                s.push(now->left);
                now->left = NULL;
            }
            else {
            //檢查完左節點然後再進入時直接打印並出棧，再檢查右節點
                ans.push_back(now->val);
                s.pop();
                if(now->right) {
                    s.push(now->right);
                }
            }
        }
        return ans;
    }
};

Binary Tree Preorder Traversal 代碼如下：

class Solution {
public:
    vector<int> preorderTraversal(TreeNode* root) {
        stack<TreeNode*> s;
        s.push(root);
        vector<int> ans;
        TreeNode* now;
        TreeNode* next;
        if(root) {
        //在入棧的同時打印節點val值
            ans.push_back(root->val);
        }
        else {
            return ans;
        }
        while(!s.empty()) {
            now = s.top();
            if(now->left) {
                ans.push_back((now->left)->val);
                s.push(now->left);
                now->left = NULL;
            }
            else if(now->right) {
                ans.push_back((now->right)->val);
                s.push(now->right);
                now->right = NULL;
            }
            else {
                s.pop();
            }
        }
        return ans;
    }
};