2.8学习总结

最新推荐文章于 2024-07-12 22:49:10 发布
最新推荐文章于 2024-07-12 22:49:10 发布
阅读量914 收藏 29
点赞数 9
文章标签： 学习 数据结构 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_80489323/article/details/136081553
版权

2.8
1.二叉树的前序遍历
2.二叉树的中序遍历
3.二叉树的后序遍历
4.⼆叉树的层序遍历
5.⼆叉树的层序遍历2
6.二叉树的右视图
7.二叉树的层平均值
8.N叉树的层序遍历
9.每个树行中找最大值
10.填充每个节点的下一个右侧节点指针
11.填充每个节点的下一个右侧节点指针2
12.生命之树（树状DP）
13.最大子树和
14.没有上司的舞会
15.对称二叉树
16.完全二叉树的节点个数
17.二叉树的最大深度
18.二叉树的最小深度
19.翻转二叉树

二叉树的前序遍历：https://leetcode.cn/problems/binary-tree-preorder-traversal/description/
class Solution {
public:
    void Traversal(TreeNode *cur,vector<int>&a){
        if (cur==NULL) return;
        a.push_back(cur->val);
        Traversal(cur->left,a);
        Traversal(cur->right,a);
    }
    vector<int> preorderTraversal(TreeNode* root) {
        vector<int>a;
        Traversal(root,a);
        return a;
    }
};
二叉树的中序遍历https://leetcode.cn/problems/binary-tree-inorder-traversal/description/
class Solution {
public:
    void traversal(TreeNode *cur,vector<int>&a){
        if (cur==NULL)return ;
        traversal(cur->left,a);
        a.push_back(cur->val);
        traversal(cur->right,a);
    }
    vector<int> inorderTraversal(TreeNode* root) {
        vector<int>a;
        traversal(root,a);
        return a;
    }
};
二叉树的后序遍历https://leetcode.cn/problems/binary-tree-postorder-traversal/description/
class Solution {
public:
    void traversal(TreeNode *cur,vector<int>&a){
        if (cur==NULL) return;
        traversal(cur->left,a);
        traversal(cur->right,a);
        a.push_back(cur->val);
    }
    vector<int> postorderTraversal(TreeNode* root) {
        vector<int>a;
        traversal(root,a);
        return a;
    }
};
⼆叉树的层序遍历https://leetcode.cn/problems/binary-tree-level-order-traversal/description/
class Solution {
public:
    vector<vector<int>> levelOrder(TreeNode* root) {
        queue<TreeNode*>que;
        if (root!=NULL) que.push(root);
        vector<vector<int> >res;
        while(!que.empty()){
            int size=que.size();
            vector<int>a;
            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);
                a.push_back(node->val);
            }
            res.push_back(a);
        }
        return res;
    }
};
⼆叉树的层序遍历2https://leetcode.cn/problems/binary-tree-level-order-traversal-ii/description/
class Solution {
public:
    vector<vector<int>> levelOrderBottom(TreeNode* root) {
        queue<TreeNode*>q;
        if (root!=NULL) q.push(root);
        vector<vector<int> >res;
        while (!q.empty()){
            int size=q.size();
            vector<int>a;
            for (int i=0;i<size;++i){
                TreeNode* now=q.front(); q.pop();
                if (now->left) q.push(now->left);
                if (now->right) q.push(now->right);
                a.push_back(now->val);
            }
            res.push_back(a);
        }
        reverse(res.begin(),res.end());
        return res; 
    }
};
二叉树的右视图https://leetcode.cn/problems/binary-tree-right-side-view/

思路：标记每一层的最后一个节点

class Solution {
public:
    vector<int> rightSideView(TreeNode* root) {
        queue<TreeNode*>q;
        vector<int>res;
        if (root!=NULL)q.push(root);
        int d=0;
        while (!q.empty()){
            int size=q.size();
            vector<int>a;
            d++;
            for (int i=0;i<size;++i){
                TreeNode* cur=q.front(); q.pop();
                if (cur->left) q.push(cur->left);
                if (cur->right) q.push(cur->right);
                if (i==size-1) res.push_back(cur->val);
            }
        }
        return res;
    }
};
二叉树的层平均值https://leetcode.cn/problems/average-of-levels-in-binary-tree/description/
class Solution {
public:
    vector<double> averageOfLevels(TreeNode* root) {
        vector<double>res;
        queue<TreeNode*>q;
        if (root!=NULL) q.push(root);
        while (!q.empty()){
            int size=q.size();
            double sum=0.0;
            for (int i=0;i<size;++i){
                TreeNode* node=q.front(); q.pop();
                if (node->left) q.push(node->left);
                if (node->right) q.push(node->right);
                sum+=node->val;
            }
            res.push_back(sum/size);
        }
        return res;
    }
};
N叉树的层序遍历https://leetcode.cn/problems/n-ary-tree-level-order-traversal/description/
class Solution {
public:
    vector<vector<int>> levelOrder(Node* root) {
        queue<Node*>q;
        vector<vector<int> >res;
        if (root!=NULL) q.push(root);
        while (!q.empty()){
            int size=q.size();
            vector<int>a;
            for (int i=0;i<size;++i){
                Node* node=q.front(); q.pop();
                a.push_back(node->val);
                for (int i=0;i<node->children.size();++i){
                    if (node->children[i]) q.push(node->children[i]);
                }
            }
            res.push_back(a);
        }
        return res;
    }
};
每个树行中找最大值https://leetcode.cn/problems/find-largest-value-in-each-tree-row/description/
class Solution {
public:
    vector<int> largestValues(TreeNode* root) {
        queue<TreeNode*>q;
        vector<int>res;
        if (root!=NULL) q.push(root);
        while (!q.empty()){
            int size=q.size();
            int maxn=INT_MIN;
            for (int i=0;i<size;++i){
                TreeNode* node=q.front(); q.pop();
                maxn=max(maxn,node->val);
                if (node->left) q.push(node->left);
                if (node->right) q.push(node->right);
            }
            res.push_back(maxn);
        }
        return res;
    }
};
填充每个节点的下一个右侧节点指针https://leetcode.cn/problems/populating-next-right-pointers-in-each-node/description/
class Solution {
public:
    Node* connect(Node* root) {
        queue<Node*>q;
        if (root!=NULL) q.push(root);
        while (!q.empty()){
            int size=q.size();
            Node* nodepre;
            Node* node;
            for (int i=0;i<size;++i){
                if(i==0){
                    nodepre=q.front(); q.pop();
                    node=nodepre;
                }else{
                    node=q.front(); q.pop();
                    nodepre->next=node;
                    nodepre=node;
                }
                if (node->left) q.push(node->left);
                if (node->right) q.push(node->right);
            }
            nodepre->next=NULL;
        }
        return root;
    }
};
填充每个节点的下一个右侧节点指针2https://leetcode.cn/problems/populating-next-right-pointers-in-each-node-ii/description/
class Solution {
public:
    Node* connect(Node* root) {
        queue<Node*>q;
        if (root!=NULL) q.push(root);
        while (!q.empty()){
            int size=q.size();
            Node* nodepre;
            Node* node;
            for (int i=0;i<size;++i){
                if(i==0){
                    nodepre=q.front(); q.pop();
                    node=nodepre;
                }else{
                    node=q.front(); q.pop();
                    nodepre->next=node;
                    nodepre=node;
                }
                if (node->left) q.push(node->left);
                if (node->right) q.push(node->right);
            }
            nodepre->next=NULL;
        }
        return root;
    }
};
二叉树的最大深度https://leetcode.cn/problems/maximum-depth-of-binary-tree/description/
class Solution {
public:
    int maxDepth(TreeNode* root) {
        queue<TreeNode*>q;
        vector<int>res;
        if (root!=NULL)q.push(root);
        int d=0;
        while (!q.empty()){
            int size=q.size();
            vector<int>a;
            d++;
            for (int i=0;i<size;++i){
                TreeNode* cur=q.front(); q.pop();
                if (cur->left) q.push(cur->left);
                if (cur->right) q.push(cur->right);
                if (i==size-1) res.push_back(cur->val);
            }
        }
        return d;
    }
};
二叉树的最小深度https://leetcode.cn/problems/minimum-depth-of-binary-tree/description/
class Solution {
public:
    int minDepth(TreeNode* root) {
        queue<TreeNode*>q;
        vector<int>res;
        if (root!=NULL)q.push(root);
        int d=0;
        while (!q.empty()){
            int size=q.size();
            vector<int>a;
            d++;
            for (int i=0;i<size;++i){
                TreeNode* cur=q.front(); q.pop();
                bool flag1=false,flag2=false;
                if (cur->left) q.push(cur->left);
                else flag1=true;
                if (cur->right) q.push(cur->right);
                else flag2=true;
                if (flag1 && flag2) return d;
            }
        }
        return 0;
    }
};
翻转二叉树https://leetcode.cn/problems/invert-binary-tree/description/
class Solution {
public:
    TreeNode* invertTree(TreeNode* root) {
        queue<TreeNode*>q;
        if (root!=NULL)q.push(root);
        while (!q.empty()){
            int size=q.size();
            for (int i=0;i<size;++i){
                TreeNode* cur=q.front(); q.pop();
                swap(cur->left,cur->right);
                if (cur->left) q.push(cur->left);
                if (cur->right) q.push(cur->right);
            }
        }
        return root;
    }
};
对称二叉树https://leetcode.cn/problems/symmetric-tree/
class Solution {
public:
    bool compare(TreeNode* left,TreeNode * right){
        if (left==NULL && right==NULL) return true;
        else if (left!=NULL && right==NULL) return false;
        else if (left==NULL && right!=NULL) return false;
        else if (left->val !=right->val) return false;
        return compare(left->left,right->right) && compare(left->right,right->left);
    }
    bool isSymmetric(TreeNode* root) {
        return compare(root->left,root->right);
    }
};
完全二叉树的节点个数https://leetcode.cn/problems/count-complete-tree-nodes/description/
class Solution {
public:
    int countNodes(TreeNode* root) {
        queue<TreeNode*>q;
        int cnt=0;
        if (root!=NULL)q.push(root);
        while (!q.empty()){
            int size=q.size();
            for (int i=0;i<size;++i){
                TreeNode* node=q.front(); q.pop();
                cnt++;
                if (node->left) q.push(node->left);
                if (node->right) q.push(node->right);
            }
        }
        return cnt;
    }
};
生命之树https://www.luogu.com.cn/problem/P8625

题目描述

在 X 森林里，上帝创建了生命之树。

他给每棵树的每个节点（叶子也称为一个节点）上，都标了一个整数，代表这个点的和谐值。

上帝要在这棵树内选出一个节点集合 �S（允许为空集），使得对于 �S 中的任意两个点 �,�a,b，都存在一个点列 �,�1,�2,⋯ ,��,�a,v1​,v2​,⋯,vk​,b 使得这个点列中的每个点都是 �S 里面的元素，且序列中相邻两个点间有一条边相连。

在这个前提下，上帝要使得 �S 中的点所对应的整数的和尽量大。

这个最大的和就是上帝给生命之树的评分。

经过 atm 的努力，他已经知道了上帝给每棵树上每个节点上的整数。但是由于 atm 不擅长计算，他不知道怎样有效的求评分。他需要你为他写一个程序来计算一棵树的分数。

输入格式

第一行一个整数 �n 表示这棵树有 �n 个节点。

第二行 �n 个整数，依次表示每个节点的评分。

接下来 �−1n−1 行，每行 22 个整数 �,�u,v，表示存在一条 �u 到 �v 的边。由于这是一棵树，所以是不存在环的。

输出格式

输出一行一个数，表示上帝给这棵树的分数。

输入输出样例

输入 #1复制

5
1 -2 -3 4 5
4 2
3 1
1 2
2 5

输出 #1复制

8

说明/提示

对于 30%30% 的数据，�≤10n≤10。

对于 100%100% 的数据，0<�≤105,0<n≤105, 每个节点的评分的绝对值不超过 106106。

时限 3 秒, 256M。

思路：树形DP的板子，主要通过DFS遍历实现，本题的大意主要是从一棵无根树中，求出一个子树，使得所有节点的权值之和最大，主要是通过DFS的方法，以任一节点为根开始DFS

#include <bits/stdc++.h>
using namespace std;
#define lowbit(x) (x& - (x))
#define int long long
const int N=1e5+5;
int dp[N];
vector<int>tree[N];//用邻接表存储图
int res;
void dfs(int u,int fa){
	for (int i=0;i<tree[u].size();++i){
		int son=tree[u][i];
		if (son!=fa){
			dfs(son,u);//继续遍历，当前节点作为父亲节点
			if (dp[son]>0) dp[u]+=dp[son];
		}
	}
	res=max(res,dp[u]);
}
signed main(){
	int n; 	cin>>n;
	for (int i=1;i<=n;++i){    //初始化DP数组
		int x;	cin>>x;
		dp[i]=x;
	}
	for (int i=0;i<n-1;++i){
		int u,v;
		cin>>u>>v;
		tree[u].push_back(v),tree[v].push_back(u);    //构造邻接表，双向边
	}
	dfs(1,-1);
	cout<<res;
}
最大子树和https://www.luogu.com.cn/problem/P1122

题目描述

小明对数学饱有兴趣，并且是个勤奋好学的学生，总是在课后留在教室向老师请教一些问题。一天他早晨骑车去上课，路上见到一个老伯正在修剪花花草草，顿时想到了一个有关修剪花卉的问题。于是当日课后，小明就向老师提出了这个问题：

一株奇怪的花卉，上面共连有 �N 朵花，共有 �−1N−1 条枝干将花儿连在一起，并且未修剪时每朵花都不是孤立的。每朵花都有一个“美丽指数”，该数越大说明这朵花越漂亮，也有“美丽指数”为负数的，说明这朵花看着都让人恶心。所谓“修剪”，意为：去掉其中的一条枝条，这样一株花就成了两株，扔掉其中一株。经过一系列“修剪“之后，还剩下最后一株花（也可能是一朵）。老师的任务就是：通过一系列“修剪”（也可以什么“修剪”都不进行），使剩下的那株（那朵）花卉上所有花朵的“美丽指数”之和最大。

老师想了一会儿，给出了正解。小明见问题被轻易攻破，相当不爽，于是又拿来问你。

输入格式

第一行一个整数 � (1≤�≤16000)n (1≤N≤16000)。表示原始的那株花卉上共 �n 朵花。

第二行有 �n 个整数，第 �i 个整数表示第 �i 朵花的美丽指数。

接下来 �−1n−1 行每行两个整数 �,�a,b，表示存在一条连接第 �a 朵花和第 �b 朵花的枝条。

输出格式

一个数，表示一系列“修剪”之后所能得到的“美丽指数”之和的最大值。保证绝对值不超过 21474836472147483647。

输入输出样例

输入 #1复制

7
-1 -1 -1 1 1 1 0
1 4
2 5
3 6
4 7
5 7
6 7

输出 #1复制

3

说明/提示

数据范围及约定

  • 对于 60%60% 的数据，有 1≤�≤10001≤N≤1000；

  • 对于 100%100% 的数据，有 1≤�≤160001≤N≤16000。

思路：树形DP

#include <bits/stdc++.h>
using namespace std;
#define lowbit(x) (x& - (x))
#define int long long
const int N=16005;
int dp[N];
vector<int>tree[N];
int res=-2147483647;
void dfs(int u,int fa){
	for (int i=0;i<tree[u].size();++i){
		int son=tree[u][i];
		if (son!=fa){
			dfs(son,u);
			if (dp[son]>0) dp[u]+=dp[son];
		}
	}
	res=max(dp[u],res);
}
signed main(){
	int n;
	cin>>n;
	for (int i=1;i<=n;++i){
		cin>>dp[i];
	}
	for (int i=0;i<n-1;++i){
		int a,b;
		cin>>a>>b;
		tree[a].push_back(b);
		tree[b].push_back(a);
	}
	dfs(1,-1);
	cout<<res;
}
没有上司的舞会https://www.luogu.com.cn/problem/P1352

题目描述

某大学有 �n 个职员，编号为 1…�1…n。

他们之间有从属关系，也就是说他们的关系就像一棵以校长为根的树，父结点就是子结点的直接上司。

现在有个周年庆宴会，宴会每邀请来一个职员都会增加一定的快乐指数 ��ri​，但是呢，如果某个职员的直接上司来参加舞会了，那么这个职员就无论如何也不肯来参加舞会了。

所以，请你编程计算，邀请哪些职员可以使快乐指数最大，求最大的快乐指数。

输入格式

输入的第一行是一个整数 �n。

第 22 到第 (�+1)(n+1) 行，每行一个整数，第 (�+1)(i+1) 行的整数表示 �i 号职员的快乐指数 ��ri​。

第 (�+2)(n+2) 到第 2�2n 行，每行输入一对整数 �,�l,k，代表 �k 是 �l 的直接上司。

输出格式

输出一行一个整数代表最大的快乐指数。

输入输出样例

输入 #1复制

7
1
1
1
1
1
1
1
1 3
2 3
6 4
7 4
4 5
3 5

输出 #1复制

5

说明/提示

数据规模与约定

对于 100%100% 的数据，保证 1≤�≤6×1031≤n≤6×103，−128≤��≤127−128≤ri​≤127，1≤�,�≤�1≤l,k≤n，且给出的关系一定是一棵树。

思路：树形DP，由于存在制约关系，所以增加DP数组的维度，从而来确定状态

#include <bits/stdc++.h>
using namespace std;
#define lowbit(x) (x& - (x))
#define int long long
const int N=16005;
int dp[N][2],w[N];
vector<int>tree[N];
int res=-2147483647;
void dfs(int u,int fa){
	dp[u][0]=0;
	dp[u][1]=w[u];
	for (int i=0;i<tree[u].size();++i){
		int son=tree[u][i];
		if (son!=fa){
			dfs(son,u);
			dp[u][0]+=max(dp[son][1],dp[son][0]);
			dp[u][1]+=dp[son][0];
		}
	}
}
signed main(){
	int n;
	cin>>n;
	for (int i=1;i<=n;++i){
		cin>>w[i];
	}
	for (int i=0;i<n-1;++i){
		int a,b;
		cin>>a>>b;
		tree[a].push_back(b);
		tree[b].push_back(a);
	}
	dfs(1,-1);
	cout<<max(dp[1][1],dp[1][0]);
}
啊这泪目了
关注
  • 9
    点赞
  • 踩
  • 29
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
大数据学习路线总结
默主归沙的博客
06-03 2万+
这是一篇大数据学习路线和相关面试总结，可以符合当下主流组件的使用。
Protel2.8 安装包
03-27
总结，Protel 2.8作为一款经典的电路设计软件，虽然已经较为过时，但其功能齐全且对初学者友好。通过学习和熟练掌握，可以在一定程度上满足基础的电路设计需求。不过，考虑到技术的发展，建议同时关注更现代的EDA...
基于RTX30显卡的ArcGIS Pro2.8深度学习环境配置
qq_33339770的博客
10-14 5958
问题描述 基于不明原因，ArcGIS Pro2.8并不支持RTX30显卡，在深度学习模型训练中会出现模型精度极低，loss等值为nan的情况，具体可看ESRI讨论贴：https://github.com/Esri/deep-learning-frameworks/issues/17 帖中总结出的问题具体如下： 解决思路 进入正题，配置argis pro2.8深度学习环境以支持RTX30显卡的思路是： 1、安装CUDA11和对应cudnn； 2、arcgis pro2.8深度学习环境库包替换。 1、
form builder学习总结整理
loveforever__的博客
08-12 3519
from builder学习 ebs from
深度学习知识点总结
qq_39223444的博客
04-02 1879
文章目录1.深度学习是什么2.基础知识2.1 为什么要使用神经网络2.2 为什么更深的网络好2.3 更多的数据是否有利于更深的神经网络？2.4 不平衡数据是否会摧毁神经网络？2.5 无监督降维提供的是帮助还是摧毁？2.6 批大小如何影响测试正确率？2.7 初始化如何影响训练?2.8 不同层的权重是否以不同的速度收敛？2.9 正则化如何影响权重？2.10 神经网络训练中的梯度消失与梯度爆炸2.11 Batchnorm原理2.12 损失函数Softmax函数交叉熵2.13 dropout的原理：2.14 L0
STL学习2常用容器2.8总结
Schlangemm的博客
03-01 120
ESL2.8 限制性估计的种类学习笔记
01-20
该书学习难度较高，有很棒的学者将其翻译成中文并放在自己的个人网站上，翻译质量非常高，本博客中有关翻译的内容都是出自该学者的网页，个人解读部分才是自己经过查阅资料和其他学者的学习笔记，结合个人理解总结成...
AXURE学习总结.pdf
08-18
AXURE学习总结 AXURE 是一种常用的原型设计工具，能够帮助设计师快速创建交互式原型，提高设计效率和效果。本文将对 AXURE 的基本概念和功能进行总结，内容涵盖工作区、常用元件、变量和交互等方面。 一、工作区 ...
Vxworks学习笔记
11-03
个人前几年学习Vxworks时，整理的笔记，总给大家了。 1 基于硬盘启动的Vxworks环境搭建 3 2 Vxworks引导盘制作 6 2.1 通过DOS加载VxWorks方法 6 2.2 Bootrom三种类型 7 2.3 VxWorks映象 7 2.4 Bootrom.sys最快制作...
机器学习课程笔记完整版
05-21
2.8每日作业 三、分类算法 3.1数据集介绍与划分 3.2sklearn转换器和估计器 3.3K-近邻算法 3.4模型选择与调优 3.5朴素贝叶斯算法 3.6决策树 3.7集成学习方法之随机森林 3.8总结 3.9每日作业 四、回归与聚类算法 ...
爬虫学习日记
wuhu_czy的博客
07-12 236
爬虫python code
Autoware.universe 高效学习第三章 -- 智驾技术务虚会之智驾技术栈讨论 其一
cy1641395022的博客
07-10 648
Autoware.universe 高效学习第三章 -- 智驾技术务虚会之智驾技术栈讨论 其一
ROS基础学习-ROS运行管理
周陽讀書
07-11 529
ROS运行管理。
jmeter-beanshell学习5-beanshell加减乘除运算
朱文宇的博客
07-08 284
jmeter使用beanshell，jmeter beanshell脚本编写，beanshell进行加减乘除运算
【安卓学习】文本切换器
m0_73241073的博客
07-08 622
文本切换器的使用
Python 学习中什么是异常处理，如何使用 try、except、finally ？
Itmastergo的博客
07-12 450
异常是程序执行过程中发生的非正常事件，这些事件会中断正常的程序指令流。当程序遇到错误时，Python 会抛出一个异常对象，异常对象包含了错误的类型和相关的信息。
Qt/QML学习-动画元素
QT、QML
07-12 287
Qt/QML学习-动画元素
【C++进阶学习】第六弹——set和map——体会用C++来构建二叉搜索树
最新发布
2301_80220607的博客
07-12 975
【C++进阶学习】第六弹——set和map——数据结构进阶知识点，适合初学者学习！！！
NPDP含金量高吗？什么人适合学习NPDP？
PMP项目管理的博客
07-09 904
开始报名后先提交报名资料，通过审核后缴纳考试费用，即算报名成功；如果报名成功后被抽中审核了的话，则须提交相关资料进行资格审查，通过审查即可参加考试，未通过审核则会将考试费用退还给您；
Golang2-new.docx
02-18
Golang2-new.docx是一份个人学习golang笔记，是从多种教程中总结而来，作为入门参考。该笔记包括以下目录： 1. 入门 1.1 Hello World 1.2 命令行参数 2. 程序结构 2.1 类型 2.1.1 命名类型（named type）与未...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值