剑指 Offer 32 从上到下打印二叉树

剑指 Offer 32 - I. 从上到下打印二叉树

从上到下打印出二叉树的每个节点，同一层的节点按照从左到右的顺序打印。

解题思路

用队列存储待遍历节点，当队列非空时，取出节点存储值并向队列添加左右子节点，若子节点为空则不添加，只pop元素。

代码

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:

    vector<int> levelOrder(TreeNode* root) {
        vector<int> num;
        queue<TreeNode*> a;
        TreeNode* proot=root;
        if(proot!=nullptr){
            a.push(proot);
        }
        
        while(a.empty()==false){
            proot=a.front();
            a.pop();
            num.push_back(proot->val);
            if(proot->left!=nullptr ){
                a.push(proot->left);
            }
            if(proot->right!=nullptr ){
                a.push(proot->right);
            }   
        }
        return num;
          
    }
};

剑指 Offer 32 - II. 从上到下打印二叉树 II

从上到下按层打印二叉树，同一层的节点按从左到右的顺序打印，每一层打印到一行。

解题思路

和第一题的思路相同，这里多了两个数，分别记录每层共有多少个节点，剩余多少个节点未打印，用vector存储每一层的节点的值，当每一层的值遍历存储完后，把该层存储在一个二维vector中。

代码

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    vector<vector<int>> levelOrder(TreeNode* root) {
        vector<vector<int>> print;
        
        queue<TreeNode*> a;
        TreeNode* proot=root;
        int linenum=0;
        int remainnum=0;
        if(proot!=nullptr){
            a.push(proot);
            linenum=1;
            remainnum=1;
        }
        while(a.empty()==false){
            vector<int> num;
            remainnum=linenum;
            linenum=0;
            while(remainnum!=0){
                proot=a.front();
                a.pop();
                remainnum--;
                num.push_back(proot->val);
                if(proot->left!=nullptr ){
                    linenum++;
                    a.push(proot->left);
                }
                if(proot->right!=nullptr ){
                    linenum++;
                    a.push(proot->right);
                }   
            }
            print.push_back(num);
            
        }
        return print;

    }
};

剑指 Offer 32 - III. 从上到下打印二叉树 III

请实现一个函数按照之字形顺序打印二叉树，即第一行按照从左到右的顺序打印，第二层按照从右到左的顺序打印，第三行再按照从左到右的顺序打印，其他行以此类推。

解题思路一

和前面的思路类似，但是在存储节点的值时，分别用一个队列和一个栈来存储，队列用来从左向右输出，栈用来从右向左输出。

代码

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    vector<vector<int>> levelOrder(TreeNode* root) {
        vector<vector<int>> print;
        queue<TreeNode*> a;
        stack<int> s;
        queue<int> q;
        int i=-1;
        
        TreeNode* proot=root;
        int linenum=0;
        int remainnum=0;
        if(proot!=nullptr){
            a.push(proot);
            linenum=1;
            remainnum=1;
        }
        while(a.empty()==false){
            vector<int> num;
            remainnum=linenum;
            linenum=0;
            i=i+1;
            while(remainnum!=0){
                proot=a.front();
                a.pop();
                remainnum--;
                if(i%2==0){
                    q.push(proot->val);
                }else{
                    s.push(proot->val);
                }
                if(proot->left!=nullptr ){
                    linenum++;
                    a.push(proot->left);
                }
                if(proot->right!=nullptr ){
                    linenum++;
                    a.push(proot->right);
                }   
            }
            while(s.empty()==false){
                num.push_back(s.top());
                s.pop();
            }
            while(q.empty()==false){
                num.push_back(q.front());
                q.pop();
            }
            print.push_back(num);    
        }
        return print;
    }
};

解题思路二

用两个栈分别存储每一层的节点。

代码

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    vector<vector<int>> levelOrder(TreeNode* root) {
        vector<vector<int>> print;
        queue<TreeNode*> a;
        stack<int> s;
        queue<int> q;
        int i=-1;
        
        TreeNode* proot=root;
        int linenum=0;
        int remainnum=0;
        if(proot!=nullptr){
            a.push(proot);
            linenum=1;
            remainnum=1;
        }
        while(a.empty()==false){
            vector<int> num;
            remainnum=linenum;
            linenum=0;
            i=i+1;
            while(remainnum!=0){
                proot=a.front();
                a.pop();
                remainnum--;
                if(i%2==0){
                    q.push(proot->val);
                }else{
                    s.push(proot->val);
                }
                if(proot->left!=nullptr ){
                    linenum++;
                    a.push(proot->left);
                }
                if(proot->right!=nullptr ){
                    linenum++;
                    a.push(proot->right);
                }   
            }
            while(s.empty()==false){
                num.push_back(s.top());
                s.pop();
            }
            while(q.empty()==false){
                num.push_back(q.front());
                q.pop();
            }
            print.push_back(num);    
        }
        return print;
    }
};