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

最新推荐文章于 2025-12-16 16:07:35 发布

原创最新推荐文章于 2025-12-16 16:07:35 发布 · 188 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#队列 #二叉树 #数据结构 #算法

算法竞赛专栏收录该内容

148 篇文章

订阅专栏

本文介绍了一种从上到下打印二叉树节点的方法，确保同一层节点按从左到右顺序输出。通过秩实现按行输出，利用队列进行广度优先搜索，展示了两种队列实现方式。

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

例如:

给定二叉树: [3,9,20,null,null,15,7],
3
/ \
9 20
/ \
15 7
返回：
[3,9,20,15,7]

提示：

节点总数 <= 1000

解题思路

通过二叉树的秩来实现按行输出的可能，将不同层次的数据从左到右依次存入数组中，再利用双重循环放入需要返回的数组中，实现层次输出。

代码展示

/**
 * 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 {
    vector<vector<int>>res = vector<vector<int>>(1000,vector<int>());
public:
    vector<int> Order(TreeNode* root, int k) {
        vector<int>T;
        if (root){
            res[k].push_back(root->val);
            Order(root->left, k+1);
            Order(root->right, k+1);
        }
        return T;
    }

    vector<int> levelOrder(TreeNode* root) {
        vector<int>result;
        if (root)
        {
            res[0].push_back(root->val);
            Order(root->left, 1);
            Order(root->right, 1);


            for (int i=0;!res[i].empty();i++)
                for (int j=0;j<res[i].size();j++)
                    result.push_back(res[i][j]);
        }
        return result;
    }
};

优化思路

利用队列这个容器将节点按顺序存储起来，整体看来类似于一次广度优先搜索（BFS），没存入一个跟结点的值，便将它下属节点存放到队列中。

队列代码展示

// 单队列
class Solution {
public:
    vector<int> levelOrder(TreeNode* root) {
        vector<int>res;

        if(root)
        {
            queue<TreeNode*>queueTreeNode;
            queueTreeNode.push(root);
            while(queueTreeNode.size())
            {
                TreeNode* pNode = queueTreeNode.front();
                queueTreeNode.pop();

                res.push_back(pNode->val);

                if(pNode->left)
                    queueTreeNode.push(pNode->left);
                if(pNode->right)
                    queueTreeNode.push(pNode->right);
            }
        }

        return res;
    }
};

// 双队列
class Solution {
public:
    vector<int> levelOrder(TreeNode* root) {
        vector<int>res;

        if(root)
        {
            deque<TreeNode*>dequeTreeNode;
            dequeTreeNode.push_back(root);
            while(dequeTreeNode.size())
            {
                TreeNode* pNode = dequeTreeNode.front();
                dequeTreeNode.pop_front();

                res.push_back(pNode->val);

                if(pNode->left)
                    dequeTreeNode.push_back(pNode->left);
                if(pNode->right)
                    dequeTreeNode.push_back(pNode->right);
            }
        }

        return res;
    }
};