13.树(2) | 二叉树的层序遍历、翻转二叉树II、对称二叉树

已于 2023-07-13 13:59:56 修改
阅读量229 收藏
点赞数 2
分类专栏： 代码随想录 文章标签： 算法 leetcode c++
于 2022-10-07 22:40:51 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43469527/article/details/127195126
版权

        今天的题目有下面10道：

         题目比较多，但第2~8道均是在第1道层序遍历的模板基础上根据题目稍作修改即可。每一道题都有递归和迭代2种解法，2种方法都灵活使用还是有难度的。

        第1道题（102.二叉树的层序遍历）是二叉树的第4种遍历方式——层序遍历。同样有递归和迭代2种实现方式。迭代方式和广度优先是一样的，用队列实现，只需要将队头节点的val不断放入结果res中，并添加其左右子节点进队列，直到队列空为止，相对较容易。其中需要注意要在内部循环开始前就记录队列的size()，否则在内部循环途中其size()值会动态变化。

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

        递归方式的函数参数除了当前节点和用于保存结果的vector之外，还需要当前节点的深度值depth，用来当作vector的下标。递归的终止条件是当前节点为空，之后要先根据depth和vector当前大小来扩展vector（添加vector<int>()），再向vector的第depth个元素中添加当前元素的val，最后再分别递归当前节点的左、右子节点。

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

        第2道题（107.二叉树的层次遍历 II）只需要在第1道题（102.二叉树的层序遍历）基础上将结果vector进行reverse()即可。

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

        第3道题（199.二叉树的右视图）只需要在第1道题（102.二叉树的层序遍历）的基础上将用于保存结果的vector改为仅在每层最后一个元素时才添加val即可。

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

        第4道题（637.二叉树的层平均值）只需在第1道题（102.二叉树的层序遍历）基础上，在每一层中记录当前层的val之和，并在当前层结束后计算平均值即可。

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

                第5道题（429.N叉树的层序遍历）只需在第1道题（102.二叉树的层序遍历）基础上，在循环中再添加内层循环，用来添加当前节点的所有子节点进队列。

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

        第6道题（515.在每个树行中找最大值）只需在第1道题（102.二叉树的层序遍历）基础上，在每层中记录当前层的val最大值即可。

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

        第7题（116.填充每个节点的下一个右侧节点指针）需在第1道题（102.二叉树的层序遍历）基础上，在内部循环中将每一个节点的next指向下一个节点，也就是当前节点被pop()后的队首元素即可。要注意对每层最后一个元素区别对待，使其next指向NULL。

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

         二刷：各种树的定义

  • 完美二叉树：深度为k，节点数为2^(k + 1) - 1的树；
  • 完全二叉树：除最下面一层外其他层是满的，且最后一层靠左分布；
  • 满二叉树：每个节点都是0个或2个子节点，没有只有1个子节点的节点。

        第8题（117.填充每个节点的下一个右侧节点指针II）与  第7题（116.填充每个节点的下一个右侧节点指针）的区别在于，前者是二叉树，后者更具体，是“完美二叉树”，但在解决方法上没有区别，代码实现与上一题一致。

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

        第9题（226.翻转二叉树）也分为递归解法和迭代解法。递归解法较简单，分前序、中序、后序遍历3种。前序首先交换当前节点的左、右2个子节点，再分别对左、右子节点进行反转操作；后序遍历首先分别对左、右子节点进行反转操作，再将已经反转好的左、右2个子节点进行交换；中序遍历首先对左子节点进行反转，再将左右子节点交换，注意此时新的左子节点是旧的未经过反转的右子节点，新的右子节点才是旧的已经反转好的左子节点，所以最后一步应该对新的左子节点进行反转操作。3种方式分别如下：

        前序递归完整代码：

class Solution {
public:
    void invert(TreeNode* cur) {
        if (cur == nullptr) {
            return;
        }
        swap(cur->left, cur->right);
        invert(cur->left);
        invert(cur->right);
    }
    TreeNode* invertTree(TreeNode* root) {
        invert(root);
        return root;
    }
};

        后序递归的invert()：

    void invert(TreeNode* cur) {
        if (cur == nullptr) {
            return;
        }
        invert(cur->left);
        invert(cur->right);
        swap(cur->left, cur->right);
    }

        中序递归的的invert()：

    void invert(TreeNode* cur) {
        if (cur == nullptr) {
            return;
        }
        invert(cur->left);
        swap(cur->left, cur->right);
        invert(cur->left);
    }

        这道题的迭代方式在有了层序遍历的基础之后也比较容易，只需在层序遍历的过程中对每个当前节点进行左、右子节点的swap()操作即可。

class Solution {
public:
    TreeNode* invertTree(TreeNode* root) {
        if (root == nullptr) {
            return root;
        }
        queue<TreeNode*> que;
        que.push(root);
        while (!que.empty()) {
            int size = que.size();
            for (int i = 0; i < size; ++i) {
                TreeNode *cur = que.front();
                que.pop();
                swap(cur->left, cur->right);
                if (cur->left) {
                    que.push(cur->left);
                }
                if (cur->right) {
                    que.push(cur->right);
                }
            }
        }
        return root;
    }
};

        另外，该实现方法中的队列也可换用栈（递归能实现的，栈也能实现），其他地方不变。而该实现方法既是层序遍历，也是一种广度优先的搜索，也可以用深度优先，既迭代方式的前序遍历（非统一方式的即为将上面的队列换成栈，下面代码为统一方式的）：

class Solution {
public:
    TreeNode* invertTree(TreeNode* root) {
        if (root == nullptr) {
            return root;
        }
        stack<TreeNode*> st;
        st.push(root);
        while (!st.empty()) {
            TreeNode *cur = st.top();
            st.pop();
            if (cur != nullptr) {
                if (cur->right) {
                    st.push(cur->right);
                }
                if (cur->left) {
                    st.push(cur->left);
                }
                st.push(cur);
                st.push(nullptr);
            }
            else {
                cur = st.top();
                st.pop();
                swap(cur->left, cur->right);
            }
        }
        return root;
    }
};

        第10题（101. 对称二叉树）同样有递归和迭代2种解法。递归法要判断左右子树是否对称，即两个子树的外侧元素、内侧元素是否相等，所以遍历方式只能是后序遍历，但不是绝对的“左->右->中”后序，而是对左子树和右子树分别进行“左->右->中”和“右->左->中”的“后序遍历”。递归函数参数为左、有两子树，需要判断两子树是否空的各种相关情况，两个都空返回true，只有一个空则返回false，其余情况要根据它们内内侧和外侧的对称结果进行判断。

class Solution {
public:
    bool areSym(TreeNode *l, TreeNode *r) {
        if (l == nullptr && r == nullptr) {
            return true;
        }
        if (l && r && l->val == r->val) {
            bool sameOutside = areSym(l->left, r->right);
            bool sameInside = areSym(l->right, r->left);
            return sameOutside && sameInside;
        }
        else {
            return false;
        }
    }
    bool isSymmetric(TreeNode* root) {
        if (root == nullptr) {
            return true;
        }
        return areSym(root->left, root->right);
    }
};

        迭代法让树的左子树，右子树分别按“中->左->右”的“先序”和“中->右->左”的“先序”将其元素放入队列中，每取出一对，就进行比较，并将其各自的左右/右左节点放入队列中，直到某次比较不相等就返回false，或队列为空就返回true。

class Solution {
public:
    bool isSymmetric(TreeNode* root) {
        if (root == nullptr) {
            return true;
        }
        queue<TreeNode*> que;
        que.push(root->left);
        que.push(root->right);
        while (!que.empty()) {
            TreeNode *cur1 = que.front();
            que.pop();
            TreeNode *cur2 = que.front();
            que.pop();
            if (cur1 == nullptr && cur2 == nullptr) {
                continue;
            }
            if (cur1 == nullptr || cur2 == nullptr || cur1->val != cur2->val) {
                return false;
            }
            que.push(cur1->left);
            que.push(cur2->right);
            que.push(cur1->right);
            que.push(cur2->left);
        }
        return true;
    }
};

代码中的队列仅为一个容器，仅要求可以成对放入和按照放入的“对”取出即可，所以替换成栈（其余地方不改）也可以实现。

非社会人士
关注
  • 2
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【代码随想录|二叉树p02 | （更正二叉树输入）226.反转二叉树 101.对称二叉树 104.二叉树的最大深度 111.二叉树的最小深度 】
daisyholly的博客
07-16 450
输入输出。
【数据结构练习题】二叉树(1)——1.相同的树2.另一颗树的子树3.翻转二叉树4.平衡二叉树5.对称二叉树
HD_13的博客
04-18 1647
给你两棵二叉树 root 和 subRoot ，检验 root 中是否包含和 subRoot 具有相同结构和节点值的子树，如果存在返回 true 否则返回 false。同样去用子问题的思想去剖析这个问题，先判断这个 subRoot 是不是root的子树，然后再去通过递归的方式判断是不是root左右子树的子树。只要确定根结点结构上和值都是相同的，后面直接去递归根结点的左右子树即可。
代码随想录第十五天|二叉树层序遍历、226.翻转二叉树、101.对称二叉树
suanheuo的博客
11-15 228
fifteen
【Java】代码随想录二叉树02| 层序遍历、翻转二叉树、对称二叉树（一口气打十二个）
weixin_43562105的博客
03-10 973
中我们讲到了二叉树的遍历方式包括深度优先遍历（前序、中序、后序）以及广度优先遍历即层次遍历，深度优先遍历既可以用迭代法，又可以用递归法来实现，而。本题遍历只能是“后序遍历”，因为我们要通过递归函数的返回值来判断两个子树的内侧节点和外侧节点是否相等。①参数和返回值：参数是左子树节点和右子树节点（比较两颗子树），返回值类型为bool。DFS前序遍历（中左右）：先交换左右孩子节点，再反转左子树，翻转右子树。比较左节点的左/右孩子和右节点的右/左孩子，都对称则返回true。左子树为空，右子树不为空——false；
二叉树的层序遍历 II
jinduo16的博客
04-14 95
给定一个二叉树，返回其节点值自底向上的层序遍历。 （即按从叶子节点所在层到根节点所在的层，逐层从左向右遍历） 例如： 给定二叉树 [3,9,20,null,null,15,7], 3 / \ 9 20 / \ 15 7 返回其自底向上的层序遍历为： [ [15,7], [9,20], [3] ] 来源：力扣（LeetCode） 链接：https://leetcode-cn.com/problems/binary-tree-level-order-t...
20230622 | 102. 二叉树的层序遍历、226. 翻转二叉树、101.对称二叉树
qq_45885369的博客
06-22 122
给你二叉树的根节点 root ，返回其节点值的 层序遍历。（即逐层地，从左到右访问所有节点）。示例 1：输入：root = [3,9,20,null,null,15,7]输出：[[3],[9,20],[15,7]]示例 2：输入：root = [1]输出：[[1]]示例 3：输入：root = []输出：[]
（补）算法训练Day15 | LeetCode226. 翻转二叉树（10种遍历方式的应用）；LeetCode101. 对称二叉树（考查遍历两个二叉树）
weixin_47284299的博客
10-08 573
（补）算法训练Day15 | LeetCode226. 翻转二叉树（10种遍历方式的应用）；LeetCode101. 对称二叉树（考查遍历两个二叉树）
算法练习题13——除自身以外数组的乘积（动态规划）
hello77的blogggg 祝你得偿所愿
09-04 456
给你一个整数数组nums，返回 数组answer，其中answer[i]等于nums中除nums[i]之外其余各元素的乘积。
LeetCode LCR088.使用最小花费爬楼梯
m0_63816268的博客
09-03 1031
动态规划
力扣刷题--1534. 统计好三元组【简单】
m0_75266675的博客
09-04 253
力扣刷题--1534. 统计好三元组【简单】
【算法】单词出现次数和位置统计
最新发布
Hanbuhuic的博客
09-04 300
编写一个程序，用于统计一个给定单词在一段文本中出现的次数以及第一次出现的位置。如果单词在文本中出现，则输出出现次数和第一次出现的位置（位置从0开始计算）。如果单词没有出现，则输出-1。
P7492 [传智杯 #3 决赛] 序列
summ1ts的博客
09-03 373
的数组，表示区间内所有数的二进制表示下某一位是否为1，但这太难写，最后无奈去看官方题解，发现只要维护区间所有数的按位与和And，如果(And&k)==k的话那就不用修改了。那样的话这个题就很简单了，维护最大子段和可以见。一道类似势能线段树的题，区间按位或上k，不满足区间可合并的性质，只能暴力的单点修改。，如果我们能找到一个方法，能够判定区间里的数，或上k后是否有改变，就可以避免。至于时间复杂度用类似势能分析的方法分析一波就行了，时间复杂度。我一开始想的是线段树里维护一个。但是考虑按位或的性质，
循环结构程序
BlueBachke的博客
09-03 452
循环结构的基础知识
算法的学习笔记—把数字翻译成字符串
业精于勤，荒于嬉
08-31 960
通过动态规划的方法，我们可以高效地计算出一个数字字符串有多少种不同的翻译方法。这个问题不仅考察了我们对动态规划的理解，还让我们熟悉了如何处理字符串中的边界情况和状态转移。希望通过这个例子的讲解，能够帮助你更好地理解动态规划的应用。😁热门专栏推荐想学习vue的可以看看这个java基础合集数据库合集redis合集nginx合集linux合集手写机制微服务组件spring_尘觉springMVCmybit欢迎大家加入我的社区尘觉社区文章到这里就结束了，如果有什么疑问的地方请指出，诸佬们一起来评论区一起讨论
碰撞检测 | 详解矩形AABB与OBB碰撞检测算法(附ROS C++可视化)
FRIGIDWINTER的博客
09-03 1970
矩形包围盒碰撞检测的核心原理是用矩形近似待检测物体轮廓，通过计算两个矩形间是否有重叠区域来进行碰撞判断。常用的包围形式有轴对齐包围盒(Axis-Aligned Bounding Box, AABB)以及更精细化具有角度的方向包围盒(Oriented Bounding Box, OBB)。本文详解这两种碰撞检测算法，并给出基于C++的算法实现和ROS可视化仿真案例
[排序和二分] 绝对差值和
StudyingPanda的博客
08-31 528
我们不妨取出一个局部去观察，首先，对于任意一个位置的i，abs(nums1[i]-nums2[i])就是这个位置对于答案的贡献，如果我们用j位置的数去置换掉i位置（0<=i,j<n，其中n为nums1数组的长度），那么这个位置的贡献就变成了abs(nums1[j]-nums2[i])。其实也比较容易发现，我们只需要让nums1[j]接近nums2[i]即可，也就是说我们二分查找一下nums1数组中和nums2[i]接近的两个数（可能更小，也可能更大），然后比较哪个更小即可。将第一个元素替换为第二个元素：[
977.有序数组的平方
argcargv的博客
08-31 231
将双指针l、r分别从头和尾向中间移动（简化了很多，不用再处理边界条件）：基本相同写法（将双指针从中将最小值的下表，向两边移动）组成的新数组，要求也按。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值