二叉树层次遍历相关题目

102. 二叉树的层次遍历

class Solution {
public:
    vector<vector<int>> levelOrder(TreeNode* root) {
        vector<vector<int>> res;
        if(root==nullptr)
            return res;
        
        queue<TreeNode*> que;
        que.push(root);
        while(!que.empty()){
            int n = que.size(); //记录当前层元素的个数
            vector<int> level;
            for(int i=0;i<n;i++){
                TreeNode* tmp = que.front();
                que.pop();
                level.push_back(tmp->val);
                if(tmp->left)
                    que.push(tmp->left);
                if(tmp->right)
                    que.push(tmp->right);
            }
            res.push_back(level);
            
        }
        return res;
    }
};

　　

107. 二叉树的层次遍历 II

给定一个二叉树，返回其节点值自底向上的层次遍历。 （即按从叶子节点所在层到根节点所在的层，逐层从左向右遍历）

方法一：使用队列，每次遍历一层后，将遍历的结果使用头插法。插入到二维数组的头部，实现逆序。

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

执行16ms

方法二 使用递归方法（通过递归实现逆序）

class Solution {
public:
    vector<vector<int>> levelOrderBottom(TreeNode* root) {
        vector<vector<int>> res;
        if(root==nullptr)
            return res;
        queue<TreeNode*> que;
        que.push(root);
        levelOrderBottom(que, res);
        return res;
        
    }
    void levelOrderBottom(queue<TreeNode*> que,vector<vector<int>>& res){
        if(que.empty())
            return;
        vector<int> arr;
        queue<TreeNode*> queNext; //用于存储下一层的结点
        while(!que.empty()){  //将当前层存储在arr中，并将下一层结点存储在queNext中。然后递归，最后在将arr数组push进res中
            TreeNode* tmp = que.front();
            que.pop();
            arr.push_back(tmp->val);
            if(tmp->left)
                queNext.push(tmp->left);
            if(tmp->right)
                queNext.push(tmp->right);    
        }
        
        levelOrderBottom(queNext, res);
        res.push_back(arr);
        return;
    }
};

　　

103. 二叉树的锯齿形层次遍历（之字形遍历）

方法一：使用两个栈

两个stack各自保存一层数据，然后先进后出的特性加上左右节点先后入栈的顺序细节（具体谁先谁后可以看代码）即可恰好对应zigZag的Z字形访问顺序：

右往左时右先入栈，左往右时，左先入栈。

class Solution {
public:
    vector<vector<int>> zigzagLevelOrder(TreeNode* root) {
        vector<vector<int>> res;
        if(root==nullptr)
            return res;
        
        stack<TreeNode*> sta1,sta2;
        vector<int> arr;
        TreeNode* tmp = root;
        sta1.push(tmp);
        while(true){
            while(!sta1.empty()){
                tmp = sta1.top();
                sta1.pop();
                arr.push_back(tmp->val);
                if(tmp->left)
                    sta2.push(tmp->left);
                if(tmp->right)
                    sta2.push(tmp->right);
            }
            if(!arr.empty()){
                res.push_back(arr);
                arr.clear();  //一定要清零
            }      
            else
                break;
            
            while(!sta2.empty()){
                tmp = sta2.top();
                sta2.pop();
                arr.push_back(tmp->val);
                if(tmp->right)
                    sta1.push(tmp->right);
                if(tmp->left)
                    sta1.push(tmp->left);
                
            }
            if(!arr.empty()){
                res.push_back(arr);
                arr.clear();  //一定要清零
            }
            else
                break;
        }
        return res;
    }
};