二叉树的遍历c++实现

前序遍历

递归实现

class Solution {
public:
    vector<int> preorderTraversal(TreeNode* root) {
        vector<int> res;
        if(root == NULL)
            return res;
        help(root, res);
        return res;
    }
    void help(TreeNode* root, vector<int>& res){
        if(root == NULL)
            return;
        res.push_back(root->val);
        help(root->left, res);
        help(root->right, res);
    }
};

非递归实现

将根节点压入栈；
弹出栈顶元素，然后看其是否有左右子树，按照先右后左的顺序压入栈；
重复上面的步骤。

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

中序遍历

递归实现

class Solution {
public:
    vector<int> inorderTraversal(TreeNode* root) {
        vector<int> res;
        if(root == NULL)
            return res;
        inorder(root, res);
        return res;
    }
    void inorder(TreeNode* root, vector<int>& res){
        if(root == NULL)
            return;
        inorder(root->left, res);
        res.push_back(root->val);
        inorder(root->right, res);
    }
};

非递归实现

遇到一个结点，将其压栈，并遍历其左子树；
左子树遍历结束后，从栈顶弹出这个结点并访问它；
遍历右子树。

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

后序遍历

递归实现

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

非递归实现

这里设置了两个栈：s1和s2
s1先将根节点压栈，然后弹出，s2将根节点其压栈；
然后s1按照先左后右的方式访问结点，并弹出；
而s2将s1弹出的元素压栈，最后依次输出。

class Solution {
public:
    vector<int> postorderTraversal(TreeNode* root) {
        vector<int> res;
        if(root == NULL)
            return res;
        stack<TreeNode* > s1, s2;
        s1.push(root);
        while(!s1.empty()){
            TreeNode* tmp = s1.top();
            s1.pop();
            s2.push(tmp);
            if(tmp->left)
                s1.push(tmp->left);
            if(tmp->right)
                s1.push(tmp->right);
        }
        while(!s2.empty()){
            TreeNode* cur = s2.top();
            res.push_back(cur->val);
            s2.pop();
        }
        return res;
    }
};

层序遍历

class Solution {
public:
    vector<vector<int>> levelOrder(TreeNode* root) {
        vector<vector<int> > res;
        if(root == NULL)
            return res;
        queue<TreeNode* > que;
        que.push(root);
        while(!que.empty()){
            vector<int> tmp;
            int n = que.size();
            for(int i = 0; i < n; ++i){
                TreeNode* cur = que.front();
                que.pop();
                tmp.push_back(cur->val);
                if(cur->left)
                    que.push(cur->left);
                if(cur->right)
                    que.push(cur->right);
            }
            res.push_back(tmp);
            
        }
        return res;
    }
};