二叉树的前序中序后序遍历

一、前序遍历

144. Binary Tree Preorder Traversal

递归代码实现：

/**
 * 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) {
        vector<int> preOrder;
        doPreOrderTraversal(root,preOrder);
        return preOrder;
    }
    void doPreOrderTraversal(TreeNode* root,vector<int> &preOrder){
        if(root){
            preOrder.push_back(root->val);
            doPreOrderTraversal(root->left,preOrder);
            doPreOrderTraversal(root->right,preOrder);
        }
    }
};

迭代法

/**
 * 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) {
        vector<int> res;
        stack<TreeNode*> S;
        TreeNode *p = root;
        while( p!=nullptr || !S.empty()){
            if(p){
                res.push_back(p->val);
                S.push(p);
                p = p->left;
            }else{
                p = S.top();
                S.pop();
                p = p->right;
            }
        }
        return res;
    }
};

二、中序遍历

94. Binary Tree Inorder Traversal

递归代码实现

/**
 * 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) {
        vector<int> inOrder;
        doInorderTraversal(root,inOrder);
        return inOrder;
    }
    void doInorderTraversal(TreeNode* root,vector<int> &inOrder){
        if(root){
            doInorderTraversal(root->left,inOrder);
            inOrder.push_back(root->val);
            doInorderTraversal(root->right,inOrder);
        }
    }
};

迭代法：

/**
 * 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) {
        vector<int> res;
        stack<TreeNode*> S;
        TreeNode *p = root;
        while(p!=nullptr || !S.empty()){
            if(p){
                S.push(p);
                p = p->left;
            }else{
                p = S.top();
                res.push_back(p->val);
                S.pop();
                p = p->right;
            }
        }
        return res;
    }
};

三、后续遍历

145. Binary Tree Postorder Traversal

递归代码实现

/**
 * 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) {
        vector<int> postOrder;
        doPostOrderTraversal(root,postOrder);
        return postOrder;
    }
    void doPostOrderTraversal(TreeNode* root,vector<int> &postOrder){
        if(root){
            doPostOrderTraversal(root->left,postOrder);
            doPostOrderTraversal(root->right,postOrder);
            postOrder.push_back(root->val);
        }
    }
};

迭代法：

/**
 * 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) {
        vector<int> res;
        stack<TreeNode*> S;
        TreeNode* p = root;
        TreeNode* visited_right = nullptr;
        while(p!=nullptr || !S.empty()){
            if(p){
                S.push(p);
                p = p->left;
            }else{
                p = S.top();
                if(p->right != nullptr && p->right != visited_right){
                    //转向右子树
                    p = p->right;
                }else{
                    res.push_back(p->val);
                    S.pop();
                    visited_right = p;//记录最近已经取值过的结点
                    p = nullptr;//以p为根的子树已经遍历完,必须重置p指针
                }
            }
        }
        return res;
    }
};