二叉树的层序遍历之Leetcode 102, 103, 107

最新推荐文章于 2024-08-21 11:22:17 发布

上学真难

最新推荐文章于 2024-08-21 11:22:17 发布

阅读量1k

点赞数 1

文章标签：算法 leetcode 数据结构

本文链接：https://blog.csdn.net/qq_30284057/article/details/123683706

版权

本文详细介绍了二叉树的层序遍历算法，并通过LeetCode的102、103、107题，探讨了层序遍历的常规方法以及锯齿形层序遍历和倒序层序遍历的实现。针对103题，错误的代码示例被指出，并给出了正确的解决方案，强调了在添加节点时要考虑层的顺序。在107题中，通过改变添加节点的位置实现了从底部开始的层序遍历。这些方法有助于深入理解二叉树的遍历策略。

摘要由CSDN通过智能技术生成

二叉树的层序遍历

二叉树的层序遍历可通过基本的框架给定，主要思路就是从上到下遍历树，对每一层从左到右遍历。
利用队列这种数据结构，先进先出，对当前这一层的下一层的都添加进来，然后出去的就是当前这一层。对这一层的每个节点，将他的值添加进来，从队列中把他扔掉，然后询问他是否有孩子，有的话把他的孩子添加进来。
代码如下：

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    vector<vector<int>> levelOrder(TreeNode* root) {
        vector<vector<int> > res;
        if(root == nullptr)
            return res;

        queue<TreeNode*> q;
        q.push(root);

        while(!q.empty())
        {
            int sz = q.size();
            vector<int> level;
            for(int i = 0; i<sz; i++)
            {
                TreeNode* cur = q.front();
                q.pop();
                level.push_back(cur->val);
                if(cur->left!=nullptr)
                    q.push(cur->left);
                if(cur->right!=nullptr)
                    q.push(cur->right);
            }
            res.push_back(level);
        }
        return res;
    }
};

这里的代码可以直接应用于解决leetcode102. 层序遍历

在层序遍历的框架熟悉了之后，可以通过
leetcode103. 二叉树的锯齿形层序遍历
 leeltcode107. 二叉树的层序遍历Ⅱ
来加深理解和记忆框架。

leetcode103. 二叉树的锯齿形层序遍历

对于leetcode103. 二叉树的锯齿形层序遍历来说，我们需要一次从左到右遍历，一次从右到左遍历，可设置一个简单的标识变量来控制从左到右或是从右到左。在每次访问一层前更改此变量此可。

要注意，以下这种写法是错误的，这种写法只能对每层的每个节点从右到左进行遍历，但并不能保证这一层都是从右到左进行访问的。

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    vector<vector<int>> zigzagLevelOrder(TreeNode* root) {
        vector<vector<int> > res;
        int t=1;
        if(root == nullptr)
            return res;
        queue<TreeNode*> q;
        q.push(root);
        while(!q.empty())
        {
            int sz = q.size();
            vector<int> level;
            t = -t;
            for(int i = 0;i<sz;i++)
            {
                TreeNode* cur = q.front();
                q.pop();
                level.push_back(cur->val);
                if(t>0)
                {
                    if(cur->left!=nullptr)
                        q.push(cur->left);
                    if(cur->right!=nullptr)
                        q.push(cur->right);
                }
                else
                {
                    if(cur->right!=nullptr)
                        q.push(cur->right);
                    if(cur->left!=nullptr)
                        q.push(cur->left);
                }
                
            }
            res.push_back(level);
        }
        return res;
    }
};

这里每次对每个节点从左到右添加入队列，再对下一层的每个节点从右到左添加入队列，这样并不对。不能保证下一层的一层都是从右到左的。

因此正确的解法，应该是，在添加元素的时候，在头上加入和在尾巴上加入。正常从左到右应该加入尾巴上，而从右到左自然就是加载头上了。

正确的代码如下所示：

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    vector<vector<int>> zigzagLevelOrder(TreeNode* root) {
        vector<vector<int> > res;
        int t=-1;
        if(root == nullptr)
            return res;
        queue<TreeNode*> q;
        q.push(root);
        while(!q.empty())
        {
            int sz = q.size();
            vector<int> level;
            t = -t;
            for(int i = 0;i<sz;i++)
            {
                TreeNode* cur = q.front();
                q.pop();
                if(t>0)
                {
                level.push_back(cur->val);
                }
                else
                {
                    vector<int>::iterator it = level.begin();
                    level.insert(it, cur->val);
                }
                if(cur->left!=nullptr)
                    q.push(cur->left);
                if(cur->right!=nullptr)
                    q.push(cur->right);
                
            }
            res.push_back(level);
        }
        return res;
    }
};

leeltcode107. 二叉树的层序遍历Ⅱ

对于leeltcode107. 二叉树的层序遍历Ⅱ这一题来说，题目要求从底部到上面去打印，实际上我们可以先从上到下正常的层序遍历，再将其反过来就可以实现，但较麻烦。可以在存储的时候就倒着存，和上一题的解法类似，在添加每一层节点的时候，在头上加入即可实现。

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    vector<vector<int>> levelOrderBottom(TreeNode* root) {
        vector<vector<int> > res;
        if(root == nullptr)
            return res;
        queue<TreeNode*> q;
        q.push(root);
        while(!q.empty())
        {
            int sz = q.size();
            vector<int> level;
            for(int i = 0; i<sz;i++)
            {
                TreeNode* cur = q.front();
                q.pop();
                level.push_back(cur->val);
                if(cur->left!= nullptr)
                    q.push(cur->left);
                if(cur->right!= nullptr)
                    q.push(cur->right);
            }
            res.insert(res.begin(),level);
        }
        return res;
    }
};