代码随想录训练营第十五天｜层序遍历，226.翻转二叉树 ，101. 对称二叉树

已于 2023-02-17 21:17:35 修改
阅读量56 收藏
点赞数
文章标签： c++ Powered by 金山文档
于 2023-02-17 11:59:46 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ababababyyyy/article/details/129061428
版权

层序遍历

题目链接（102）：https://leetcode.cn/problems/binary-tree-level-order-traversal/comments/

代码：

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

递归法

class Solution {
public:
    vector<vector<int>> levelOrder(TreeNode* root) {
        vector<vector<int>> result;
        order(root,0,result);
        return result;
    }
    void order(TreeNode* root,int deep,vector<vector<int>>& result)
    {
        if(root == nullptr)
            return;
        if(deep == result.size())
            result.push_back(vector<int>{});
        result[deep].push_back(root->val);
        order(root->left,deep+1,result);
        order(root->right,deep+1,result);
    }
};

递归法其实不难，但是我一看到这种写法就害怕，其实可以慢慢来

题目链接（107）：https://leetcode.cn/problems/binary-tree-level-order-traversal-ii/

代码：

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

和102一样的，就是最后颠倒了下顺序

题目链接（199）：https://leetcode.cn/problems/binary-tree-right-side-view/submissions/

代码：

class Solution {
public:
    vector<int> rightSideView(TreeNode* root) {
        vector<int> result;
        if(root == 0)
            return result;
        queue<TreeNode*> que;
        que.push(root);
        while(!que.empty())
        {
            int size = que.size();
            int tmp;
            TreeNode* dp;
            for(int i = 0; i < size; i ++)
            {
                dp = que.front();
                que.pop();
                if(dp->left)
                    que.push(dp->left);
                if(dp->right)
                    que.push(dp->right);
            }
            result.push_back(dp->val);
        }
        return result;
    }
};

嘎嘎简单

题目链接（637）：https://leetcode.cn/problems/average-of-levels-in-binary-tree/

代码：

class Solution {
public:
    vector<double> averageOfLevels(TreeNode* root) {
        vector<double> result;
        queue<TreeNode*> que;
        if(root == nullptr)
            return result;
        que.push(root);
        while(!que.empty())
        {
            int size = que.size();
            double sum = 0;
            TreeNode* dp;
            for(int i = 0; i < size; i ++ )
            {
                dp = que.front();
                que.pop();
                sum += dp->val;
                if(dp->left)
                    que.push(dp->left);
                if(dp->right)
                    que.push(dp->right);
            }
            double ave = sum/size;
            result.push_back(ave);
        }
        return result;
    }
};

题目链接（429）：https://leetcode.cn/problems/n-ary-tree-level-order-traversal/submissions/

代码：

class Solution {
public:
    vector<vector<int>> levelOrder(Node* root) {
        queue<Node*> que;
        vector<vector<int>> result;
        if(root == nullptr)
            return result;
        que.push(root);
        while(!que.empty())
        {
            int size = que.size();
            Node* dp;
            vector<int> tmp;
            for(int i = 0; i < size; ++i)
            {
                dp = que.front();
                que.pop();
                tmp.push_back(dp->val);
                for(int j = 0; j < dp->children.size();j++)
                {
                    if(dp->children[j])
                        que.push(dp->children[j]);
                }
            }
            result.push_back(tmp);
        }
        return result;
    }
};

学会了n叉树多节点的孩子表示方法

题目链接（515）：https://leetcode.cn/problems/find-largest-value-in-each-tree-row/submissions/

代码：

class Solution {
public:
    vector<int> largestValues(TreeNode* root) {
        queue<TreeNode*> que;
        vector<int> result;
        if(root == nullptr)
            return result;
        que.push(root);
        while(!que.empty())
        {
            int size = que.size();
            TreeNode* dp;
            int max = INT_MIN;
            for(int i = 0 ; i < size; ++i)
            {
                dp = que.front();
                que.pop();
                if(dp->val > max)
                {
                    max = dp->val;
                }
                if(dp->left)
                    que.push(dp->left);
                if(dp->right)
                    que.push(dp->right);
            }
            result.push_back(max);
        }
        return result;
    }
};

最小值用INT_MIN表示，选最大值的时候可以用正则表达式来写：

                max = dp->val > max?dp->val:max;

题目链接（116）：https://leetcode.cn/problems/populating-next-right-pointers-in-each-node/

代码：

class Solution {
public:
    Node* connect(Node* root) {
        queue<Node*> que;
        if(root == NULL)
            return root;
        que.push(root);
        while(!que.empty())
        {
            int size = que.size();
            Node* dp;
            Node* dp2;
            for(int i = 0;i < size - 1; i++)
            {
                dp = que.front();
                que.pop();
                dp2 = que.front();
                dp->next = dp2;
                if(dp->left) que.push(dp->left);
                if(dp->right) que.push(dp->right);
            }
            dp = que.front();
            que.pop();
            dp->next = NULL;
            if(dp->left) que.push(dp->left);
            if(dp->right) que.push(dp->right);
        }
        return root;
    }
};

要注意：不能直接que.push(dp->left);que.push(dp->right);这样会把null放到队列中

也可以和代码随想录一样 获取前一个节点 然后对当前节点操作：

class Solution {
public:
    Node* connect(Node* root) {
        queue<Node*> que;
        if (root != NULL) que.push(root);
        while (!que.empty()) {
            int size = que.size();
            // vector<int> vec;
            Node* nodePre;
            Node* node;
            for (int i = 0; i < size; i++) {
                if (i == 0) {
                    nodePre = que.front(); // 取出一层的头结点
                    que.pop();
                    node = nodePre;
                } else {
                    node = que.front();
                    que.pop();
                    nodePre->next = node; // 本层前一个节点next指向本节点
                    nodePre = nodePre->next;
                }
                if (node->left) que.push(node->left);
                if (node->right) que.push(node->right);
            }
            nodePre->next = NULL; // 本层最后一个节点指向NULL
        }
        return root;

    }
};

题目链接（117）：https://leetcode.cn/problems/populating-next-right-pointers-in-each-node-ii/submissions/

代码：

class Solution {
public:
    Node* connect(Node* root) {
        if(root == NULL)
            return root;
        queue<Node*> que;
        que.push(root);
        while(!que.empty())
        {
            int size = que.size();
            Node* prenode;
            Node* node;
            for(int i = 0; i < size;i++)
            {
                if(i == 0)
                {
                    prenode = que.front();
                    que.pop();
                    if(prenode->left)
                        que.push(prenode->left);
                    if(prenode->right)
                        que.push(prenode->right);
                }else
                {
                    node = que.front();
                    que.pop();
                    prenode->next = node;
                    if(node->left)
                        que.push(node->left);
                    if(node->right)
                        que.push(node->right);
                    prenode = node;
                }
            }
            prenode->next = NULL;
        }
        return root;
    }
};

这不和上一题一样？

题目链接（104）：https://leetcode.cn/problems/maximum-depth-of-binary-tree/

代码：

class Solution {
public:
    int maxDepth(TreeNode* root) {
        return root == nullptr ? 0 : max(maxDepth(root->left),maxDepth(root->right)) + 1;
    }
};

这是递归方法，真的简单啊，但是就是很难想，应该说是不敢去想，这方面我还需要加强

再就是老方法：

class Solution {
public:
    int maxDepth(TreeNode* root) {
        if (root == NULL) return 0;
        int depth = 0;
        queue<TreeNode*> que;
        que.push(root);
        while(!que.empty()) {
            int size = que.size();
            depth++; // 记录深度
            for (int i = 0; i < size; i++) {
                TreeNode* node = que.front();
                que.pop();
                if (node->left) que.push(node->left);
                if (node->right) que.push(node->right);
            }
        }
        return depth;
    }
};

题目链接（111）：https://leetcode.cn/problems/minimum-depth-of-binary-tree/

代码：

class Solution {
public:
    int minDepth(TreeNode* root) {
        if(root == nullptr)
            return 0;
        if(root->left == nullptr && root->right)
            return minDepth(root->right) + 1;
        if(root->right == nullptr && root->left)
            return minDepth(root->left) + 1;
        return min(minDepth(root->left),minDepth(root->right)) + 1;
    }
};

跟上一题差不多 但是要注意的是 如果根结点的左节点或者右节点为空  那么构不成子树没办法判断 所以要先判断一下

class Solution {
public:
    int minDepth(TreeNode* root) {
        if (root == NULL) return 0;
        int depth = 0;
        queue<TreeNode*> que;
        que.push(root);
        while(!que.empty()) {
            int size = que.size();
            depth++; // 记录深度
            for (int i = 0; i < size; i++) {
                TreeNode* node = que.front();
                que.pop();
                if(node->left == nullptr && node->right == nullptr)
                    return depth;
                if (node->left) que.push(node->left);
                if (node->right) que.push(node->right);
            }
        }
        return depth;
    }
};

层次遍历真容易啊。。。

226.翻转二叉树

题目链接：https://leetcode.cn/problems/invert-binary-tree/submissions/

代码：

class Solution {
public:
    TreeNode* invertTree(TreeNode* root) {
        inverse(root);
        return root;
    }
    void inverse(TreeNode* root)
    {
        if(root == nullptr)
            return;
        TreeNode* tmp;
        tmp = root->left;
        root->left = root->right;
        root->right = tmp;
        inverse(root->left);
        inverse(root->right);
    }
};

击败100%的用户嘿嘿嘿

我这个是前序遍历，也可以用后序遍历，但是中序不行，交换过程的代码可以由这个替换：

swap(node->left, node->right);

中序的话：

        inverse(root->left);
        inverse(root->left);

视频链接：

https://www.bilibili.com/video/BV1sP4y1f7q7/?vd_source=3620d298fb5c81607e945a4dd 0315654

101. 对称二叉树

题目链接：

代码：

class Solution {
public:
    bool isSymmetric(TreeNode* root) {
        if(root == nullptr)
            return true;
        return compare(root->left,root->right);
    }
    bool compare(TreeNode* left,TreeNode* right)
    {
        if(left == nullptr && right != nullptr)
            return false;
        if(left != nullptr && right == nullptr)
            return false;
        if(left == nullptr && right == nullptr)
            return true;
        if(left->val != right->val)
            return false;
        bool out = compare(left->left,right->right);
        bool in = compare(left->right,right->left);
        return out&&in;
    }
};

看的代码随想录才会写的 用的是后序遍历

ababababyyyy
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
二叉树的创建与遍历C语言实现代码.zip
05-27
二叉树的创建与遍历C语言实现代码.zip二叉树的创建与遍历C语言实现代码.zip二叉树的创建与遍历C语言实现代码.zip二叉树的创建与遍历C语言实现代码.zip二叉树的创建与遍历C语言实现代码.zip二叉树的创建与遍历C语言...
二叉树的遍历二叉树的遍历二叉树的遍历二叉树的遍历.txt
05-20
二叉树的遍历二叉树的遍历二叉树的遍历二叉树的遍历二叉树的遍历
代码随想录训练营第十五天 | 层序遍历、226.翻转二叉树、101.对称二叉树
weixin_43881491的博客
04-18 244
需要使用后续遍历的方法，先判断左右子树是否对称，然后根据子树的对称结果再进一步判断整个树是否对称。
代码随想录算法训练营第15天 | 二叉树层序遍历 226.翻转二叉树 101.对称二叉树
qq_44173169的博客
01-11 416
这样一层一层地遍历就是广度优先搜索，队列先入先出的性质是最合适的。也可以用递归的方法实现，要注意递归函数的传入参数，因为我们是一层一层遍历的，所以应该传入当前节点的所属层次。不需要返回参数，只需要保存结果数组。int。
代码随想录算法训练营第十五天 | 层序遍历 、226.翻转二叉树、101.对称二叉树
Danny_8的博客
05-24 1220
使用队列来辅助遍历。记录每一层的个数，然后弹出一个节点，就把他的左右孩子放进队列中。当这一层的个数为0，就开始遍历下一行。 107.二叉树的层次遍历 II 199.二叉树的右视图 637.二叉树的层平均值 429.N叉树的层序遍历 515.在每个树行中找最大值 116.填充每个节点的下一个右侧节点指针 117.填充每个节点的下一个右侧节点指针II 这道题目说是二叉树，上面的116题目说是完整二叉树，116的代码有判断左右孩子是否为空，所以这道题代码和116是一样的。 111.二叉树的最小深度
代码随想录算法训练营第十五天| 层序遍历 226.翻转二叉树 101. 对称二叉树
qq_22081185的博客
09-07 100
层序遍历题目链接/文章讲解/视频讲解：https://programmercarl.com/0102.%E4%BA%8C%E5%8F%89%E6%A0%91%E7%9A%84%E5%B1%82%E5%BA%8F%E9%81%8D%E5%8E%86.html226.翻转二叉树 （优先掌握递归）题目链接/文章讲解/视频讲解：https://programmercarl.com/0226.%E7%BF%BB%E8%BD%AC%E4%BA%8C%E5%8F%89%E6%A0%91.html。
代码随想录算法训练营第十五天| 层序遍历 226.翻转二叉树 101.对称二叉树
amytheace的博客
05-29 107
这种涉及double的题要格外小心，能在最开始declare variable的时候设成double就直接double，一个是之后运算的时候不用cast，一个是只设置为int可能会溢出。翻转正常层序遍历就行，用 reverse(levelOrder.begin(), levelOrder.end());111. 这道题和104都有两种写的方法，level traverse或者递归遍历，递归遍历以后练。116. 用现在的front() 指向pop后的front()就行。429. 见总套路，记住套路一遍过。
代码随想录算法训练营第15天 | 层序遍历、226.翻转二叉树、101.对称二叉树
weixin_43753439的博客
04-21 145
相当于广度优先遍历之于图，使用队列来辅助实现。递归，后序遍历，通过条件进行预剪枝。递归，前序遍历，交换左右子结点。
代码随想录算法训练营第十五天 | 层序遍历、226.翻转二叉树、101.对称二叉树
owlmo的博客
12-27 1135
然后将当前节点的left指向当前的右子树，right指向当前的左子树，做翻转操作。否则进行递归处理，判断当前对应的两棵子树是否对称，判断的根据还是根据两棵子树是否为空、两棵子树的对称位置子树是否一致等。思路：进行层次遍历，如果在遍历时，发现当前有一个节点既没有左子树又没有右子树，则当前节点的深度为二叉树的最小深度。思路：进行层次遍历，然后对每层的结果做平均，注意每个节点的数值是否越过int的边界。思路：进行层序遍历，然后在遍历的过程中不断地将每层的前一个节点指向后一个节点。给你一个二叉树的根节点。
代码随想录算法训练营第十五天| 层序遍历 ，226.翻转二叉树 ，101.对称二叉树
m0_43385261的博客
03-06 149
今日任务层序遍历 ，226.翻转二叉树 ，101.对称二叉树。
代码随想录算法训练营第十八天 | 二叉树的层序遍历 226.翻转二叉树 101. 对称二叉树
qq_52149213的博客
05-04 979
感觉自己还是没有明白递归, 今天的算法理解的不通透, 之后还要继续看
代码随想录算法训练营第十五天|102.二叉树的层序遍历 226.翻转二叉树 101. 对称二叉树
滋滋牛排味的博客
05-23 255
踩坑：先看的视频，没踩什么坑思路：核心是使用队列并记录每一行的size，在遍历本行的时候下一行就入队了。
python-leetcode面试题解之第107题二叉树的层序遍历II.zip
04-29
python python_leetcode面试题解之第107题二叉树的层序遍历II
二叉树的层序遍历 II.md
11-17
二叉树的层序遍历 II.md
【C++】——Stack与Queue（含优先队列（详细解读）
m0_74092462的博客
06-09 970
优先队列是一种容器适配器，根据严格的弱排序标准，它的第一个元素总是它所包含的元素中最大的。stack是一种容器适配器，专门用在具有后进先出操作的上下文环境中，其删除只能从容器的一端进行元素的插入与提取操作。 队列是一种容器适配器，专门用于在FIFO上下文(先进先出)中操作，其中从容器一端插入元素，另一端提取元素。
C++——计算不同的非空子串个数
我发布的博客，快来抄答案吧
06-09 130
BCSP-X 11题 C++代码详解
LeetCode 算法：轮转数组c++
小金牛来了
06-09 643
LeetCode 算法：轮转数组c++
【C语言】一维数组（详解）
最新发布
lrq13965748542的博客
06-11 964
有了下标引用操作符，我们可以轻松访问到数组中的元素了，比如我们访问下标为7的元素，我们就可以使用 arr[7]，想要访问下标为3的元素，就使用 arr[3]。我们知道数组中所有元素的类型都是相同的，那只要计算出一个元素所占字节的个数，数组的元素个数就能计算出来。以后在代码中需要数组元素个数的地方就不用固定写死了，使用上面的计算，不管数组怎样变化，计算出的大小也就随着变化了。数组也是有类型的，数组算是一种自定义类型，去掉数组名留下的就是数组的类型。实现了数组的访问，现在我们也可以实现对数组中进行数据的输入。
代码随想录刷题训练营DAY 15 二叉树 Part 02 | 102. 二叉树的层序遍历 107. 二叉树的层序遍历 Ⅱ 226. 反转二叉树 101. 对称二叉树---火腿
09-23
引中提到，二叉树的层序遍历可以通过DFS或BFS来实现。其中，BFS是利用队列的先进先出特性来实现的，每一层的节点被依次加入队列中，然后逐个出队并将其子节点加入队列。 引用中给出了一个实现翻转二叉树的代码示例。该代码使用了递归法的前序遍历，对于每一个节点，交换其左右子节点，然后递归地对其左右子树进行翻转。 引用中给出了一个实现二叉树的层序遍历的代码示例。该代码使用了BFS的思想，借助队列来实现层序遍历。每一层的节点被依次加入队列中，然后逐个出队并将其子节点加入队列，同时将当前层的节点值添加到结果列表中。 综上所述，参考这些引用，可以通过BFS来实现二叉树的层序遍历，并通过递归法或迭代法来翻转二叉树。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值