代码随想录刷题题Day12

最新推荐文章于 2024-06-18 20:12:34 发布
最新推荐文章于 2024-06-18 20:12:34 发布
阅读量834 收藏 19
点赞数 20
分类专栏： 代码随想录刷题 文章标签： c++ 代码随想录 数据结构 二叉树
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/BigDavid123/article/details/134970812
版权

刷题的第十二天，希望自己能够不断坚持下去，迎来蜕变。😀😀😀
刷题语言：C++
Day12 任务
● 层序遍历 10
● 226.翻转二叉树
● 101.对称二叉树 2

1 层序遍历

一口气做十题
102.二叉树的层序遍历
107.二叉树的层次遍历II
199.二叉树的右视图
637.二叉树的层平均值
429.N叉树的层序遍历
515.在每个树行中找最大值
116.填充每个节点的下一个右侧节点指针
117.填充每个节点的下一个右侧节点指针II
104.二叉树的最大深度
111.二叉树的最小深度

层序遍历一个二叉树。就是从左到右一层一层的去遍历二叉树。
队列先进先出，符合一层一层遍历的逻辑，而用栈先进后出适合模拟深度优先遍历也就是递归的逻辑

在这里插入图片描述
102.二叉树的层序遍历
在这里插入图片描述

层序遍历模板：
C++：

class Solution {
public:
    vector<vector<int>> levelOrder(TreeNode* root) {
		vector<vector<int>> result;
		queue<TreeNode*> que;
		if (root != NULL) que.push(root);
		while (!que.empty())
		{
			int size = que.size();
			vector<int> vec;
			// 这里一定要使用固定大小size，不要使用que.size()
			while (size--)
			{
				TreeNode* node = que.front();
				que.pop();
				vec.push_back(node->val);
				if (node->left) que.push(node->left);
				if (node->right) que.push(node->right);
			}
			result.push_back(vec);
		}
		return result;
    }
};

107.二叉树的层次遍历II
在这里插入图片描述

思路：

把result数组反转一下

C++：

class Solution {
public:
    vector<vector<int>> levelOrderBottom(TreeNode* root) {
        queue<TreeNode*> que;
        vector<vector<int>> result;
        if (root != NULL) que.push(root);
        while (!que.empty())
        {
            int size = que.size();
            vector<int> vec;
            while (size--)
            {
                TreeNode* node = que.front();
                que.pop();
                vec.push_back(node->val);
                if (node->left) que.push(node->left);
                if (node->right) que.push(node->right);
            }
            result.push_back(vec);
        }
        reverse(result.begin(), result.end());// 在这里反转一下数组
        return result;
    }
};

199.二叉树的右视图
在这里插入图片描述
思路：

判断是否遍历到单层的最后面的元素，如果是，就放进result数组中，随后返回result

C++：

class Solution {
public:
    vector<int> rightSideView(TreeNode* root) {
        queue<TreeNode*> que;
        vector<int> result;
        if (root != NULL) que.push(root);
        while (!que.empty())
        {
            int size = que.size();
            for (int i = 0; i < size; i++)
            {
                TreeNode* node = que.front();
                que.pop();
                if (i == (size - 1)) result.push_back(node->val);// 将每一层的最后元素放入result数组
                if (node->left) que.push(node->left);
                if (node->right) que.push(node->right);
            }
        }
        return result;
    }
};

637.二叉树的层平均值
在这里插入图片描述
思路：

层序遍历的时候把一层求个总和在取一个均值

C++：

class Solution {
public:
    vector<double> averageOfLevels(TreeNode* root) {
        queue<TreeNode*> que;
        vector<double> result;
        if (root != NULL) que.push(root);
        while (!que.empty())
        {
            double sum = 0;// 统计每一层的和
            int size = que.size();
            for (int i = 0; i < size; i++)
            {
                TreeNode* node = que.front();
                que.pop();
                sum += node->val;
                if (node->left) que.push(node->left);
                if (node->right) que.push(node->right);
            }
            result.push_back(sum / size);// 将每一层均值放进结果
        }
        return result;
    }
};

429.N叉树的层序遍历
在这里插入图片描述
思路：

一个节点有多个孩子,用for循环

C++：

class Solution {
public:
    vector<vector<int>> levelOrder(Node* root) {
        queue<Node*> que;
        vector<vector<int>> result;
        if (root != NULL) que.push(root);
        while (!que.empty())
        {
            int size = que.size();
            vector<int> vec;
            while (size--)
            {
                Node* node = que.front();
                que.pop();
                vec.push_back(node->val);
                for (int i = 0; i < node->children.size(); i++)// 将节点孩子加入队列
                {
                    if (node->children[i]) que.push(node->children[i]);
                }
            }
            result.push_back(vec);
        }
        return result;
    }
};

515.在每个树行中找最大值
在这里插入图片描述
思路：

层序遍历，取每一层的最大值

C++：

class Solution {
public:
    vector<int> largestValues(TreeNode* root) {
        queue<TreeNode*> que;
        vector<int> result;
        if (root != NULL) que.push(root);
        while (!que.empty())
        {
            int size = que.size();
            int maxValue = INT_MIN;// 取每一层的最大值
            for (int i = 0; i < size; i++)
            {
                TreeNode* node = que.front();
                que.pop();
                maxValue = node->val > maxValue ? node->val : maxValue;
                if (node->left) que.push(node->left);
                if (node->right) que.push(node->right);
            }
            result.push_back(maxValue);// 把最大值放进数组
        }
        return result;
    }
};

class Solution {
public:
    vector<int> largestValues(TreeNode* root) {
        queue<TreeNode*> que;
        vector<int> result;
        if (root != NULL) que.push(root);
        while (!que.empty())
        {
            int size = que.size();
            vector<int> vec;
            for (int i = 0; i < size; i++)
            {
                TreeNode* node = que.front();
                que.pop();
                vec.push_back(node->val);
                if (node->left) que.push(node->left);
                if (node->right) que.push(node->right);
            }
            auto MAX = max_element(vec.begin(), vec.end());
            result.push_back(*MAX);
        }
        return result;
    }
};

116.填充每个节点的下一个右侧节点指针
在这里插入图片描述
思路：

在单层遍历的时候记录一下本层的头部节点，然后在遍历的时候让前一个节点指向本节点

C++：

class Solution {
public:
    Node* connect(Node* root) {
        queue<Node*> que;
        if (root != NULL) que.push(root);
        while (!que.empty())
        {
            int size = que.size();
            Node* node;
            Node* nodePre;
            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.填充每个节点的下一个右侧节点指针II
在这里插入图片描述
思路：

和上个题目一样

C++：

class Solution {
public:
    Node* connect(Node* root) {
        queue<Node*> que;
        if (root != NULL) que.push(root);
        while (!que.empty())
        {
            int size = que.size();
            Node* node;
            Node* nodePre;
            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;
    }
};

104.二叉树的最大深度
在这里插入图片描述
思路：

使用层序遍历是最为合适的，因为最大的深度就是二叉树的层数。在二叉树中，一层一层的来遍历二叉树，记录一下遍历的层数就是二叉树的深度
在这里插入图片描述

C++：

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

111.二叉树的最小深度
在这里插入图片描述
思路：

当左右孩子都为空的时候，才说明遍历的最低点了。如果其中一个孩子为空则不是最低点

C++：

class Solution {
public:
    int minDepth(TreeNode* root) {
        int depth = 0;
        queue<TreeNode*> que;
        if (root == NULL) return 0;
        else 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);
                // 当左右孩子都为空的时候，说明是最低点的一层
                if (!node->left && !node->right) return depth;
            }
        }
        return depth;
    }
};

2 翻转二叉树

在这里插入图片描述
思路：
在这里插入图片描述

把每一个节点的左右孩子交换一下。注意只要把每一个节点的左右孩子翻转一下，就可以达到整体翻转的效果

递归法：
在这里插入图片描述
（1）确定递归函数的参数和返回值

参数：要传入节点的指针
返回值：其实也不需要，但是题目中给出的要返回root节点的指针，可以直接使用题目定义好的函数，所以就函数的返回类型为TreeNode*

TreeNode* invertTree(TreeNode* root)

（2）确定终止条件

if (root == NULL) return root;

（3）确定单层递归的逻辑
前序遍历：中 左 右

swap(root->left, root->right);
invert(root->left);
invert(root->right);

中序遍历：左 中 右

invert(root->left);
swap(root->left, root->right);
invert(root->left);

后序遍历：左 右 中

invert(root->left);
invert(root->right);
swap(root->left, root->right);

针对二叉树的问题，解题之前一定要想清楚究竟是前中后序遍历，还是层序遍历

C++：

class Solution {
public:
    TreeNode* invertTree(TreeNode* root) {
        if (root == NULL) return root;
        swap(root->left, root->right); // 中
        invertTree(root->left);        // 左
        invertTree(root->right);       // 右
        return root;
    }
};

迭代法：
深度优先遍历
C++：

class Solution {
public:
    TreeNode* invertTree(TreeNode* root) {
        if(root == NULL) return root;
        stack<TreeNode*> st;
        st.push(root);
        while (!st.empty())
        {
            TreeNode* node = st.top();// 中
            st.pop();
            swap(node->left, node->right);
            if (node->right) st.push(node->right);// 右
            if (node->left) st.push(node->left);// 左
        }
        return root;
    }
};

广度优先遍历

层数遍历也是可以翻转这棵树的，因为层序遍历也可以把每个节点的左右孩子都翻转一遍

C++：

class Solution {
public:
    TreeNode* invertTree(TreeNode* root) {
        queue<TreeNode*> que;
        if (root != NULL) que.push(root);
        while (!que.empty())
        {
            int size = que.size();
            while (size--)
            {
                TreeNode* node = que.front();
                que.pop();
                swap(node->left, node->right);// 节点处理
                if (node->left) que.push(node->left);
                if (node->right) que.push(node->right);
            }
        }
        return root;
    }
};

3 对称二叉树

在这里插入图片描述
思路：

比较的是根节点的左子树与右子树是不是相互翻转的,比较的是两个树（这两个树是根节点的左右子树），所以在递归遍历的过程中，也是要同时遍历两棵树。

在这里插入图片描述
比较的是两个子树的里侧和外侧的元素是否相等
遍历顺序只能是后序遍历，因为要通过递归函数的返回值来判断两个子树的内侧节点和外侧节点是否相等。
因为要遍历两棵树而且要比较内侧和外侧节点，所以准确的来说是一个树的遍历顺序是左右中，一个树的遍历顺序是右左中
递归法：
（1）确定递归函数的参数和返回值
比较的是根节点的两个子树是否是相互翻转的，进而判断这个树是不是对称树，所以要比较的是两个树，参数自然也是左子树节点和右子树节点。
返回值自然是bool类型

bool compare(TreeNode* left, TreeNode* right)

（2）确定终止条件
要比较两个节点数值相不相同，首先要把两个节点为空的情况弄清楚！否则后面比较数值的时候就会操作空指针了。

  1. 左节点为空，右节点不为空，不对称，return false
  2. 左不为空，右为空，不对称 return false
  3. 左右都为空，对称，返回true
  4. 左右都不为空，比较节点数值，不相同就return false
if （left == NULL && right != NULL) return false;
else if (left != NULL && right == NULL) return false;
else if (left == NULL && right == NULL) return true;
else if (left->val != right->val) return false;

（3）确定单层递归的逻辑
处理 左右节点都不为空，且数值相同的情况

  1. 比较二叉树外侧是否对称：传入的是左节点的左孩子，右节点的右孩子。
  2. 比较内侧是否对称，传入左节点的右孩子，右节点的左孩子。
  3. 如果左右都对称就返回true ，有一侧不对称就返回false 。
bool outside = compare(left->left, right->right); // 左子树：左、 右子树：右
bool inside = compare(left->right, right->left);// 左子树：右、 右子树：左
bool result = outside && inside;// 左子树：中、 右子树：中
return result;

C++：

class Solution {
public:
    bool compare(TreeNode* left, TreeNode* right)
    {// 首先排除空节点的情况
        if (left == NULL && right != NULL) return false;
        else if (left != NULL && right == NULL) return false;
        else if (left == NULL && right == NULL) return true;
        // 排除了空节点，再排除数值不相同的情况
        else if (left->val != right->val) return false;
        // 此时就是：左右节点都不为空，且数值相同的情况
        // 此时才做递归，做下一层的判断
        bool outside = compare(left->left, right->right);
        bool inside = compare(left->right, right->left);
        bool result = outside && inside;
        return result;
    }
    bool isSymmetric(TreeNode* root) {
        if (root == NULL) return true;
        return compare(root->left, root->right);
    }
};

鼓励坚持十三天的自己😀😀😀

Big David
关注
  • 20
    点赞
  • 踩
  • 19
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
代码随想录刷题题Day39
BigDavid123的博客
01-21 893
代码随想录刷题第三十九天😀😀，本文用C++详解了最长公共子序列、不相交的线、最大子序和
代码随想录刷题题Day25
BigDavid123的博客
12-29 870
代码随想录刷题第25天😀😀😀，本文讲解了贪心算法的理论基础，以及用C++实现了分发饼干，摆动序列，最大子序和
代码随想录刷题题Day32
BigDavid123的博客
01-12 983
代码随想录刷题第三十二天😀😀😀，本文用动态规划完全背包的方法解决了爬楼梯、零钱兑换和完全平方数
C语言代码随想录刷题计划 Day1
SepMiranda的博客
03-15 1742
考研复试有机试，写点东西记录下技巧啥的，等机试前一天晚上拿出来看看
代码随想录刷题题Day29
BigDavid123的博客
01-09 1297
代码随想录刷题第二十九天😀😀😀，本文详解了0-1背包一维和二维的情况，并用C++解决了分割等和子集的问题
代码随想录刷题题Day15
BigDavid123的博客
12-17 974
代码随想录刷题第十五天😀😀😀，本文详解了如何找树左下角的值，路径总和，以及从中序与后序遍历序列构造二叉树
代码随想录刷题题Day34
BigDavid123的博客
01-15 851
代码随想录刷题第三十四天😀。本文用C++详解了打家劫舍的三个题目
代码随想录刷题题Day36
BigDavid123的博客
01-18 744
代码随想录刷题第三十六天😀😀😀，本文用C++讲解了买卖股票的最佳时机III、IV
代码随想录刷题题Day17
BigDavid123的博客
12-19 968
代码随想录刷题第十七天，本文利用C++详解了二叉搜索树的最小绝对差，二叉搜索树的众数以及最近公共祖先的思路
代码随想录刷题打卡day02
04-18
代码随想录刷题打卡day02
代码随想录-八股文 pdf
04-25
代码随想录-八股文 PDF 代码随想录-八股文 PDF 是一个涵盖了程序员学习必备的内容的知识星球精华，总结了包括 C++、Java、Go 在内的多种编程语言，数据结构和算法、操作系统、数据库、计算机网络、设计模式、Linux ...
代码随想录+刷题笔记记录
03-22
本文主要介绍代码随想录的刷题笔记记录，方便读者更好地利用该网站进行学习。 ## 刷题笔记记录的作用 刷题笔记记录是代码随想录提供的一个功能，用于记录用户在刷题过程中的解题思路和方法。它可以帮助用户更好地...
代码随想录知识星球精华 最强⼋股⽂
04-28
代码随想录知识星球精华（最强⼋股⽂） 这份PDF总结了 代码随想录知识星球 的全部精华内容，覆盖了⼏乎程序员学习必备的内容。 知识星球⾥很多录友拿到了⼤⼚offer，包括科班 和 ⾮科班的，⽽他们的每⽇学习总结都是...
代码随想录 面试大厂必备八股文
07-03
代码随想录 面试大厂八股文 手撕代码必备神器
【2024最新华为OD-C/D卷试题汇总】[支持在线评测] 停车场车位统计(100分) - 三语言AC题解(Python/Java/Cpp)
清隆学长的博客
06-15 83
K小姐经营着一个特定大小的停车场，停车场可以看成一个数组 $cars[]$，其中 $1$ 表示有车，$0$ 表示没车。现在停车场内停放着大小不一的车辆，其中小车占一个车位(长度 $1$)，货车占两个车位(长度 $2$)，卡车占三个车位(长度 $3$)。 K小姐想知道，按照当前停车场的停放情况，最少有多少辆车停在停车场内。你能帮帮她吗？ ### 输入描述 输入一个由 $0$ 和 $1$ 组成的字符串，以逗号分隔，表示停车场的车位情况。其中 $1$ 表示有车，$0$ 表示没车，字符串长度不超过 $1000
C++ 72 之 友元和类模版
最新发布
LSG_Down的博客
06-18 240
【代码】C++ 72 之 友元和类模版。
【C++提高编程-05】----C++之Deque容器实战
一伦明悦的博客
06-15 1170
Deque（双端队列）是C++ STL中的一种序列容器
C++ shared_ptr
qq_40135848的博客
06-15 1525
C++ shared_ptr
牛客上代码随想录怎么看题刷题
04-12
牛客网上的代码随想录是一个非常好的刷题平台，它提供了大量的编程题目和解题思路。在牛客网上刷题，可以按照以下步骤进行： 1. 注册并登录牛客网账号。 2. 在主页上找到“代码随想录”板块，点击进入。 3. 在代码...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值