二叉树从上到下打印，打印多行、之字形打印

最新推荐文章于 2021-03-12 21:54:07 发布

wuxtwu

最新推荐文章于 2021-03-12 21:54:07 发布

阅读量113

点赞数

CC 4.0 BY-SA版权

分类专栏：数据结构和刷题

本文链接：https://blog.youkuaiyun.com/xnmc2014/article/details/90744254

数据结构和刷题专栏收录该内容

77 篇文章

订阅专栏

本文详细介绍了二叉树的三种遍历方式：从上到下、多行打印及之字形打印。通过使用队列和栈数据结构，实现对二叉树节点的逐层访问，适用于计算机科学和算法设计的学习者。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

两道题思路基本一致，要有一个变量记录当前层节点的数量

从上到下打印：（标准的BFS）

/*
struct TreeNode {
	int val;
	struct TreeNode *left;
	struct TreeNode *right;
	TreeNode(int x) :
			val(x), left(NULL), right(NULL) {
	}
};*/
class Solution {
public:
    vector<int> PrintFromTopToBottom(TreeNode* root) {
           vector<int>ans;
        if (root==nullptr)return ans;
        queue<TreeNode*>q;
        q.push(root);
        
        while(!q.empty())
        {
            TreeNode* tmp = q.front();
            q.pop();
            
            ans.push_back(tmp->val);
            
            if (tmp->left)q.push(tmp->left);
            if (tmp->right)q.push(tmp->right);
            
        }
        
        return ans;
        
        
        
    }
};

多行打印： (多了变量，cnt记录当前层剩余的、cnt_tmp记录下一层的节点数)

/*
struct TreeNode {
    int val;
    struct TreeNode *left;
    struct TreeNode *right;
    TreeNode(int x) :
            val(x), left(NULL), right(NULL) {
    }
};
*/
class Solution {
public:
        vector<vector<int> > Print(TreeNode* pRoot) {
        
          vector<vector<int> >ans;
            if (pRoot==nullptr)return ans;
            
            queue<TreeNode*>q;
            q.push(pRoot);
            
            int cnt = 1;
            int cnt_tmp = 0;
             vector<int>one;
            while(!q.empty())
            {
                
                TreeNode* tmp = q.front();
                q.pop();
                
                one.push_back(tmp->val);
                cnt--;
                
                if (tmp->left)
                {
                    q.push(tmp->left);
                    cnt_tmp++;
                }
                if (tmp->right){
                    q.push(tmp->right);
                    cnt_tmp++;
                }
                
                if (cnt==0)
                {
                    ans.push_back(one);
                    cnt = cnt_tmp;
                    cnt_tmp = 0;
                    one.clear();
                }
                
            }
            return ans;
            
        }
    
};

之字形打印

可以用两个栈，存相邻的层。入栈顺序不同，记录奇偶。

/*
struct TreeNode {
    int val;
    struct TreeNode *left;
    struct TreeNode *right;
    TreeNode(int x) :
            val(x), left(NULL), right(NULL) {
    }
};
*/
class Solution {
public:
    vector<vector<int> > Print(TreeNode* pRoot) {
        
        vector<vector<int> >ans;
        if(pRoot==nullptr)return ans;
        
        stack<TreeNode*>s1;
        stack<TreeNode*>s2;
        
        s1.push(pRoot);
       
        vector<int>first_vector;
        
        int flag = 0;
        
        int cnt = 1;
        int cnt_tmp= 0;
        
        while(!s1.empty() || !s2.empty())
        {
            if (flag==0 && !s1.empty())
            {
                TreeNode* node_tmp = s1.top();
                s1.pop();
                cnt--;
                
                first_vector.push_back(node_tmp->val);
                
                if (node_tmp->left)s2.push(node_tmp->left);
                if (node_tmp->right)s2.push(node_tmp->right);
                
            }
            
            if (flag==1 && !s2.empty())
            {
                TreeNode* node_tmp = s2.top();
                s2.pop();
                cnt--;
                
                first_vector.push_back(node_tmp->val);
               
                if (node_tmp->right)s1.push(node_tmp->right);
                if (node_tmp->left)s1.push(node_tmp->left);
            }
            
            if (cnt==0)
            {
                if (flag==1)
                {
                    flag = 0;
                    cnt_tmp = s1.size();
                }
                else if (flag==0)
                {
                    flag = 1;
                    cnt_tmp = s2.size();
                }
                cnt = cnt_tmp;
                if (first_vector.size()!=0)ans.push_back(first_vector);
                first_vector.clear();
                
            }
           
        }
        return ans;
    }
    
};