LeetCode刷题day15
Posted 爱编程的大李子
tags:
篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了LeetCode刷题day15相关的知识,希望对你有一定的参考价值。
算法打卡第十五天,今天你刷题了吗
😄😄😄😄😄😄😄😄😄😄
😃😃😃😃😃😃😃😃😃😃
💓💓💓大家一起来刷题!💓💓💓
😍😍😍😍😍😍😍😍😍😍
😘😘😘😘😘😘😘😘😘😘
144. 二叉树的前序遍历
94. 二叉树的中序遍历
145. 二叉树的后序遍历
思路分析:
递归和迭代两种方法都可进行处理
方法一:递归
参考代码
//前序
void preorder(TreeNode* T) {
if(T) {
V.push_back(T->val);
preorder(T->left);
preorder(T->right);
}
}
//中序
void inorder(TreeNode* T) {
if(T) {
inorder(T->left);
V.push_back(T->val);
inorder(T->right);
}
}
//后序
void postorder(TreeNode* T) {
if(T) {
postorder(T->left);
postorder(T->right);
V.push_back(T->val);
}
}
vector<int> V;
vector<int> xxxorderTraversal(TreeNode* root) {
xxxorder(root);
return V;
}
方法二:迭代
本质上是在模拟递归,因为在递归的过程中使用了系统栈,所以在迭代的解法中常用Stack来模拟系统栈。
以前序遍历为例
- 首先我们应该创建一个Stack用来存放节点,首先我们想要打印根节点的数据,此时Stack里面的内容为空,所以我们优先将头结点加入Stack,然后打印。
- 之后我们应该先打印左子树,然后右子树。所以先加入Stack的就是右子树,然后左子树。
此时你能得到的流程如下:
参考代码2
//迭代做法.
vector<int> preorderTraversal(TreeNode* root) {
if(root==null){
return {};
}
vector<int> V;
TreeNode* cur = root;
stack<TreeNode*> S;
S.push(root);
while(!stack.empty()){
TreeNode* node = S.top();
S.pop();
V.push_back(node->val);//通过改变该语句的顺序,来决定是先序,中序和后序..
if(node->right != NULL){
S.push(node->right);
}
if(node->left!=NULL){
S.push(node->left);
}
}
return V;
}
102. 二叉树的层序遍历
给你一个二叉树,请你返回其按 层序遍历 得到的节点值。 (即逐层地,从左到右访问所有节点)。
示例:
二叉树:[3,9,20,null,null,15,7],
3
/ \\
9 20
/ \\
15 7
返回其层序遍历结果:
[
[3],
[9,20],
[15,7]
]
思路分析:
参考 BFS的使用场景总结
参考代码
#include<bits/stdc++.h>
using namespace std;
https://leetcode-cn.com/problems/binary-tree-level-order-traversal/
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) {}
};
vector<vector<int>> levelOrder(TreeNode* root) {
vector<vector<int>> V;
queue<TreeNode*> Q;
if(root==NULL){
return {};
}
Q.push(root);
while(!Q.empty()){
int n = Q.size();//计算当前层元素的个数
vector<int> v;
for(int i = 0;i <n;i++){//将当前层元素弹出放到v中.
TreeNode* node = Q.front();
Q.pop();
v.push_back(node->val);
if(node->left){
Q.push(node->left);
}
if(node->right){
Q.push(node->right);
}
}
V.push_back(v);
}
return V;
}
104. 二叉树的最大深度
给定一个二叉树,找出其最大深度。
二叉树的深度为根节点到最远叶子节点的最长路径上的节点数。
说明: 叶子节点是指没有子节点的节点。
示例:
给定二叉树 [3,9,20,null,null,15,7],
3
/ \\
9 20
/ \\
15 7
返回它的最大深度 3 。
参考代码
int maxDepth(TreeNode* root) {
int m,n;
if(root){
return 0;
}else{
m = maxDepth(root->left);//递归计算左子树深度
n = maxDepth(root->right);//递归计算右子树深度
if(m>n){
return m+1;//返回左右子树的最大值+1
}else{
return n+1;
}
}
}
101. 对称二叉树
给定一个二叉树,检查它是否是镜像对称的。
例如,二叉树 [1,2,2,3,4,4,3] 是对称的。
1
/ \\
2 2
/ \\ / \\
3 4 4 3
但是下面这个 [1,2,2,null,3,null,3] 则不是镜像对称的:
1
/ \\
2 2
\\ \\
3 3
方法一:递归
根据题目的描述,镜像对称,就是左右两边相等,也就是左子树和右子树是相当的。
注意这句话,左子树和右子相等,也就是说要递归的比较左子树和右子树。
- 我们将根节点的左子树记做 left,右子树记做 right。比较 left 是否等于 right,不等的话直接返回就可以了。
- 如果相当,比较 left 的左节点和 right 的右节点,再比较 left 的右节点和 right 的左节点
比如看下面这两个子树(他们分别是根节点的左子树和右子树),能观察到这么一个规律:
- 左子树 2 的左孩子 == 右子树 2 的右孩子
- 左子树 2 的右孩子 == 右子树 2 的左孩子
2 2
/ \\ / \\
3 4 4 3
/ \\ / \\ / \\ / \\
8 7 6 5 5 6 7 8
根据上面信息可以总结出递归函数的两个条件:
终止条件:
- left 和 right 不等,或者 left 和 right 都为空
- 递归的比较 left.left 和 right.right,递归比较 left.right 和 right.left
动态图如下:
时间复杂度:O(n),因为要遍历 n 个节点
空间复杂度是 O(n),空间复杂度是递归的深度,也就是跟树高度有关,最坏情况下树变成一个链表结构,高度是n。
参考代码:
#include<bits/stdc++.h>
using namespace std;
//https://leetcode-cn.com/problems/symmetric-tree/
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) {}
};
// 递归+dfs
bool dfs(TreeNode* left,TreeNode* right){
//递归终止的条件
if(left==NULL&&right==NULL){
return true;//肯定对称
}
if(left==NULL||right==NULL){
return false;
}
if(left->val!=right->val){
return false;
}
return dfs(left->left,right->right)&&dfs(left->right,right->left);
}
bool isSymmetric(TreeNode* root) {
if(root==NULL){
return true;
}
//调用递归函数,比较左节点和右节点
return dfs(root->left,root->right);
}
int main()
{
return 0;
}
方法二:迭代
回想下递归的做法:
当两个子树的根节点相等时,就比较:左子树的 left 和 右子树的 right.
现在我们改用队列来实现,思路如下:
- 首先从队列中拿出两个节点(left 和 right)比较
- 将 left 的 left 节点和 right 的 right 节点放入队列
- 将 left 的 right 节点和 right 的 left 节点放入队列
时间复杂度是O(n),空间复杂度是 O(n)
参考代码:
#include<bits/stdc++.h>
using namespace std;
//https://leetcode-cn.com/problems/symmetric-tree/
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) {}
};
// 迭代
bool isSymmetric(TreeNode* root) {
if(root==NULL || (root->left==NULL && root->right==NULL)){
return true;
}
//用队列保存左右节点
queue<TreeNode*> Q;
Q.push(root->left);
Q.push(root->right);
while(!Q.empty()){
TreeNode* left = Q.front();
Q.pop();
TreeNode *right = Q.front();
Q.pop();
if(left==NULL&&right==NULL){
// return true;
continue;//进行下一组节点的判断
}
if(left==NULL||right==NULL){
return false;
}
if(left->val!=right->val){
return false;
}
//将左节点的左孩子,右节点的右孩子放入队列.
Q.push(left->left);
Q.push(right->right);
//将左节点的右孩子,右节点的左孩子放入队列
Q.push(left->right);
Q.push(right->left);
}
return true;
}
😜😜😜😜😜 大家卷起来! 😝😝😝😝😝
以上是关于LeetCode刷题day15的主要内容,如果未能解决你的问题,请参考以下文章
Leetcode刷题100天—15. 三数之和( 排序)—day30
Leetcode刷题100天—215. 数组中的第K个最大元素(优先队列)—day15