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;
    }
};

Morris 遍历
中序：

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    vector<int> inorderTraversal(TreeNode* root) {
        std::vector<int> ans;
        if (root == nullptr) {
            return ans;
        }
        TreeNode* curNode = root;
        while(curNode) {
            TreeNode* preNode = curNode->left;
            if (preNode == nullptr) {
                //  如果左节点为空，则打印此节点，并且访问右节点
                ans.push_back(curNode->val);
                curNode = curNode->right;
            } else {
                //  如果左节点不为空，则找到左节点最右子节点，也即是中序遍历的前继节点
                while(preNode->right && preNode->right != curNode) {
                    preNode = preNode->right;
                }
                if (preNode->right) {
                    //  如果不为空，也即是再次回到curNode，则打印此节点，还原前继节点的右节点，再访问右节点
                    ans.push_back(curNode->val);
                    preNode->right = nullptr;
                    curNode = curNode->right;
                } else {
                    //  如果为空，则在前继节点右节点打标记，再访问左节点
                    preNode->right = curNode;
                    curNode = curNode->left;
                }
            }
        }
        return ans;
    }
};

中序：

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    vector<int> preorderTraversal(TreeNode* root) {
        std::vector<int> ans;
        if (root == nullptr) {
            return ans;
        }
        TreeNode* curNode = root;
        while(curNode) {
            TreeNode* inorderPreNode = curNode->left;
            if (inorderPreNode == nullptr) {
                //  如果左节点为空，则打印此节点，并且访问右节点
                ans.push_back(curNode->val);
                curNode = curNode->right;
            } else {
                //  如果左节点不为空，则找到左节点最右子节点，也即是中序遍历的前继节点
                while(inorderPreNode->right && inorderPreNode->right != curNode) {
                    inorderPreNode = inorderPreNode->right;
                }
                if (inorderPreNode->right) {
                    //  如果不为空，也即是再次回到curNode，则还原前继节点的右节点，再访问右节点
                    inorderPreNode->right = nullptr;
                    curNode = curNode->right;
                } else {
                    //  如果为空，则打印此节点，在前继节点右节点打标记，再访问左节点
                    inorderPreNode->right = curNode;
                    ans.push_back(curNode->val);
                    curNode = curNode->left;
                }
            }
        }
        return ans;
    }
};

后序，转化为先右后左的前序遍历：

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    vector<int> postorderTraversal(TreeNode* root) {
        std::vector<int> ans;
        if (root == nullptr) {
            return ans;
        }
        TreeNode* curNode = root;
        while(curNode) {
            TreeNode* inorderPreNode = curNode->right;
            if (inorderPreNode == nullptr) {
                //  如果右节点为空，则打印此节点，并且访问左节点
                ans.push_back(curNode->val);
                curNode = curNode->left;
            } else {
                //  如果右节点不为空，则找到右节点最左子节点，也即是中序遍历的前继节点
                while(inorderPreNode->left && inorderPreNode->left != curNode) {
                    inorderPreNode = inorderPreNode->left;
                }
                if (inorderPreNode->left) {
                    //  如果不为空，也即是再次回到curNode，则还原前继节点的左节点，再访问左节点
                    inorderPreNode->left = nullptr;
                    curNode = curNode->left;
                } else {
                    //  如果为空，则打印此节点，在前继节点左节点打标记，再访问右节点
                    inorderPreNode->left = curNode;
                    ans.push_back(curNode->val);
                    curNode = curNode->right;
                }
            }
        }
        return std::vector<int>(ans.rbegin(), ans.rend());
    }
};