数据结构之二叉树ヾ(Ő∀Ő๑)ﾉ
一、前言
在寒假期间我会持续发一些不同知识点相关的题，意在通过这种方式让自己保持学习，也为各位同学提供一些我自己做题时的思路。考虑到知识点在网上还是比较好查找的，也有很多老师讲得很棒，所以我会更关注对于知识点的锻炼和理解，不会去讲解知识点。另外，我讲解的内容大多是我自己做题时的想法，也许有些地方对知识点理解的有问题，为防止误导其他人，如果有同学发现我有的地方说的不清楚或者有错误的话，请评论区指出，万分感谢!!☆⌒(*＾-゜)v
二、go go go
1、淘汰赛
题目描述
有 2^n(n≤7) 个国家参加世界杯决赛圈且进入淘汰赛环节。已经知道各个国家的能力值，且都不相等。能力值高的国家和能力值低的国家踢比赛时高者获胜。1 号国家和 2 号国家踢一场比赛，胜者晋级。3 号国家和 4 号国家也踢一场，胜者晋级……晋级后的国家用相同的方法继续完成赛程，直到决出冠军。给出各个国家的能力值，请问亚军是哪个国家？
输入格式
无
输出格式
无
输入输出样例
输入 #1
3
4 2 3 1 10 5 9 7
输出 #1
1
考察知识点：二叉树的概念
这道题即使我们不知道二叉树是什么也可以轻松做出来，所以难点不在于解题，而是通过淘汰赛这样生活中常见的模型让我们对二叉树是什么有一定的认知。解题思路是把数组分成两段，选出前半段和后半段的最大值，再取其中小的那个，输出下标。
AC code
#include <iostream>
#include <bits/stdc++.h>
#pragma GCC optimize(2)
#define ull unsigned long long
using namespace std;
ull n = 1;
bool cmp (int a, int b){
return a > b;
}
int t1,t2,m1,m2,r1,r2,k;
int main()
{
ios::sync_with_stdio(false);
cin >> k;
for(int i = 0 ;i < k - 1; i++){
n = n * 2;
}
for(int i = 1; i <= n; i++){
cin >> t1;
if(i == 1){
m1 = t1;
r1 = i;
}
else if(t1 > m1){
m1 = t1;
r1 = i;
}
}
for(int i = n +1; i < 2*n+1; i++){
cin >> t2;
if(i == n +1){
m2 = t2;
r2 = i;
}
else if(t2 > m2){
m2 = t2;
r2 = i;
}
}
if(m2 > m1){
cout << r1;
}
else{
cout << r2;
}
return 0;
}
2、二叉树深度
题目描述
给出每个节点的两个儿子节点，建立一棵二叉树（根节点为 1），如果是叶子节点，则输入0 0。建好树后希望知道这棵二叉树的深度。二叉树的深度是指从根节点到叶子结点时，最多经过了几层。
最多有 10^6 个结点。
输入格式
无
输出格式
无
输入输出样例
输入 #1
7
2 7
3 6
4 5
0 0
0 0
0 0
0 0
输出 #1
4
考察知识点：二叉树的深度
ヾ(ﾟ∀ﾟゞ)这道题一开始我理解错了，折腾好久。为了防止有人和我一样没怎么看懂这道题，我结合样例解释一下。样例大意是：1的儿子结点是2和7，2的儿子结点是3和6，3的儿子结点是4和5，其他都是叶子结点。这么以来这道题通过一种十分刻意的方式把难度降低了，因为我只需要按顺序录入每个结点的儿子结点然后遍历一下就好了，遍历起来也很方便。
AC code
#include <iostream>
#include <bits/stdc++.h>
#pragma GCC optimize(2)
#define ull unsigned long long
using namespace std;
//构建二叉树的结点
typedef struct node{
int l,r;
}node;
node nodes[1000005];
int m = 1;//深度的最大值
//搜索二叉树
void searchBinary(int n, int d){
if(n == 0){
return;
}
else{
m = max(d,m);
searchBinary(nodes[n].l,d+1);
searchBinary(nodes[n].r,d+1);
}
}
int main()
{
int n;
cin >> n;
for(int i = 1 ; i <= n; i++){
cin >> nodes[i].l>>nodes[i].r;
}
searchBinary(1,1);
cout << m;
return 0;
}
3、美国血统
题目描述
农夫约翰非常认真地对待他的奶牛们的血统。然而他不是一个真正优秀的记帐员。他把他的奶牛 们的家谱作成二叉树，并且把二叉树以更线性的“树的中序遍历”和“树的前序遍历”的符号加以记录而 不是用图形的方法。
你的任务是在被给予奶牛家谱的“树中序遍历”和“树前序遍历”的符号后，创建奶牛家谱的“树的 后序遍历”的符号。每一头奶牛的姓名被译为一个唯一的字母。（你可能已经知道你可以在知道树的两 种遍历以后可以经常地重建这棵树。）显然，这里的树不会有多于 26 个的顶点。 这是在样例输入和 样例输出中的树的图形表达方式：
C
/ \
/ \
B G
/ \ /
A D H
/ \
E F
树的中序遍历是按照左子树，根，右子树的顺序访问节点。
树的前序遍历是按照根，左子树，右子树的顺序访问节点。
树的后序遍历是按照左子树，右子树，根的顺序访问节点。
输入格式
第一行： 树的中序遍历
第二行： 同样的树的前序遍历
输出格式
单独的一行表示该树的后序遍历。
输入输出样例
输入 #1
ABEDFCHG
CBADEFGH
输出 #1
AEFDBHGC
考察知识点：二叉树的遍历
这道题涉及了二叉树的三种遍历，感觉很大程度提高了我对三种遍历的理解ヾ(´▽‘)ﾉ
首先我们知道前序遍历的次序是根左右，然后我们就可以找到根结点（第一个字母），然后中序遍历是左根右，所以我们就可以得到左子树和右子树。然后，前序遍历的下一个字母就是根的左儿子结点，所以我们可以把左子树再分成两部分，以此来循环，其实就是不断地切割。然后输出的时候每次都输出当前的根结点，考虑到后序遍历的特点，所以我们先遍历左和右，最后输出根结点即可。可能这么说还是比较抽象，大家可以看一下代码然后体会一下。
AC code
#include <iostream>
#include <bits/stdc++.h>
#pragma G++ optimize(2)
#define ull unsigned long long
#define ll long long
using namespace std;
string pre,inor;
/**
* 二叉树遍历函数
* x y前序遍历的范围
* a b中序遍历的范围
*/
void f(int x, int y, int a, int b){
if(x > y || a > b){
return;
}
int t = inor.find(pre[x]);
f(x + 1,x + t - a, a, t - 1);
f(x+t-a+1,y,t+1,b);
cout<<pre[x];
}
int main()
{
ios::sync_with_stdio(false);
cin >> inor >> pre;
int l = pre.length() - 1;
f(0,l,0,l);
return 0;
}
4、医院设置
题目描述
设有一棵二叉树，如图：
其中，圈中的数字表示结点中居民的人口。圈边上数字表示结点编号，现在要求在某个结点上建立一个医院，使所有居民所走的路程之和为最小，同时约定，相邻接点之间的距离为 1。如上图中，若医院建在1 处，则距离和=4+12+2×20+2×40=136；若医院建在 3 处，则距离和=4×2+13+20+40=81。
输入格式
第一行一个整数 n，表示树的结点数。
接下来的 n行每行描述了一个结点的状况，包含三个整数 w,u,v其中w 为居民人口数，u 为左链接（为 0 表示无链接），v 为右链接（为 0 表示无链接）。
输出格式
一个整数，表示最小距离和。
输入输出样例
输入 #1
5
13 2 3
4 0 0
12 4 5
20 0 0
40 0 0
输出 #1
81
说明/提示
数据规模与约定
对于 100% 的数据，保证 1≤n≤100，0≤u,v≤n，1≤w≤10^5。
考察知识点：二叉树的建立 二叉树的应用 Floyd算法
这道题可以概括为加权图的最短路径，也就自然想到了Floyd算法ლ(´ڡ`ლ)所以这里简单介绍一下Floyd算法
算法过程
1，从任意一条单边路径开始。所有两点之间的距离是边的权，如果两点之间没有边相连，则权为无穷大。
2，对于每一对顶点 u 和 v，看看是否存在一个顶点 w 使得从 u 到 w 再到 v 比已知的路径更短。如果是更新它。
核心代码
for(int k=1; k!=NODE; ++k)//对于每一个中转点
for(int i=0; i!=NODE; ++i)//枚举源点
for(int j=0; j!=NODE; ++j)//枚举终点
if(distmap[i][j]>distmap[i][k]+distmap[k][j])//不满足三角不等式
{
distmap[i][j]=distmap[i][k]+distmap[k][j];//更新
path[i][j]=k;//记录路径
}
然后再说回这道题，主要是因为数据量并不大，所以我就可以利用Floyd算法算出任意两点之间的最短路径，然后再试试把每一个点作为建立医院的点，计算其他点到这个点的距离乘上权重，然后求出最小的那个就OK了。其实这个解法很暴力哎o( =•ω•= )m
AC code
#include <iostream>
#include <bits/stdc++.h>
#pragma GCC optimize(2)
#define ull unsigned long long
#define ll long long
using namespace std;
int dis[500][500] = {
0};
int binary[1000];
int main()
{
ios::sync_with_stdio(false);
int n,l,r;
cin >> n;
//初始化
for(int i = 1; i <= n; i++){
for(int j = 1; j <= n; j++){
dis[i][j] = 100000;
}
}
//录入数据
for(int i = 1 ; i <= n; i++){
dis[i][i] = 0;
cin >> binary[i] >> l >> r;
if(l > 0){
dis[i][l] = 1;
dis[l][i] = 1;
}
if(r > 0){
dis[i][r] = 1;
dis[r][i] = 1;
}
}
//Floyd算法
for(int i = 1; i <= n; i++){
for(int k = 1; k <= n; k++){
if(i != k){
for(int j = 1; j <= n; j++){
if(i != j && k != j){
if(dis[i][j] > dis[i][k] + dis[k][j])
dis[i][j] = dis[i][k] + dis[k][j];
}
}
}
}
}
int res = 0;
//一个一个点算总和，输出最小点
for(int i = 1; i <= n; i++){
int t = 0;
for(int j = 1; j <= n; j++){
if(i != j){
t += dis[i][j] * binary[j];
}
}
if(i == 1){
res = t;
}
else{
res = min(t,res);
}
}
cout<<res;
return 0;
}
5、遍历问题
题目描述
我们都很熟悉二叉树的前序、中序、后序遍历，在数据结构中常提出这样的问题：已知一棵二叉树的前序和中序遍历，求它的后序遍历，相应的，已知一棵二叉树的后序遍历和中序遍历序列你也能求出它的前序遍历。然而给定一棵二叉树的前序和后序遍历，你却不能确定其中序遍历序列，考虑如下图中的几棵二叉树：
所有这些二叉树都有着相同的前序遍历和后序遍历，但中序遍历却不相同。
输入格式
输A数据共两行，第一行表示该二叉树的前序遍历结果s1，第二行表示该二叉树的后序遍历结果s2。
输出格式
输出可能的中序遍历序列的总数，结果不超过长整型数。
输入输出样例
输入 #1
abc
cba
输出 #1
4
考察知识点：二叉树的遍历
这道题可以看作上面第三题的一个扩展，其实在写第三题的时候我就思考过这个问题，通过这道题让我解决了这个困惑。这道题是建立在对前序和后序遍历熟练的基础上。这道题的解决思路其实很简单，只有一个儿子结点的结点会有两种情况（无法确定是左连接还是右链接），所以只需找出所有只有一个儿子结点的结点，然后输出2^这种类型的结点数。但为什么是这样的，以及怎么找出来，我是通过在纸上不断地画二叉树，不断进行前序和后序遍历来逐渐理解的。最后找出这些结点也不困难，假设在前序遍历中存在AB，且在后序遍历中存在BA，则存在一个这样的结点A，原因也是因为如果只有一个子树的话，父亲结点和儿子结点在前序遍历和后序遍历中会相邻。这也解释了为什么有了中序遍历再加一个遍历可以画出二叉树，没用中序遍历就不行，因为没有中序遍历我们就无法确定左右子树。
AC code
#include <iostream>
#include <bits/stdc++.h>
#pragma GCC optimize(2)
#define ull unsigned long long
#define ll long long
using namespace std;
inline int read(){
char ch = getchar();
int a = 0,b = 1;
while(ch < '0' || ch > '9'){
if(ch == '-'){
b = -1;
}
ch = getchar();
}
while(ch >= '0' && ch <= '9'){
a = a * 10 + ch - '0';
ch = getchar();
}
return a * b;
}
string qian,hou;//存储两个遍历的结果
int res = 1;
int main()
{
ios::sync_with_stdio(false);
cin >> qian >> hou;
int l = qian.length();
for(int i = 0; i < l - 1; i++){
for(int j = 1; j < l; j++){
//判断是否存在只有一个儿子节点的节点
if(qian[i] == hou[j] && qian[i + 1] == hou[j - 1]){
res *= 2;
}
}
}
cout << res;
return 0;
}
6、新二叉树
题目描述
输入一串二叉树，输出其前序遍历。
输入格式
第一行为二叉树的节点数 n。(1≤n≤26)
后面 n 行，每一个字母为节点，后两个字母分别为其左右儿子。
空节点用 * 表示
输出格式
二叉树的前序遍历。
输入输出样例
输入 #1
6
abc
bdi
cj*
d**
i**
j**
输出 #1
abdicj
考察知识点：二叉树的遍历
如果你已经看到这里，这道题显然难度不大，作为一个之前理解遍历之后的练手题，熟悉一下遍历的写法也是蛮好的ヾ(･ω･`｡)
AC code
#include <iostream>
#include <bits/stdc++.h>
#pragma GCC optimize(2)
#define ull unsigned long long
#define ll long long
using namespace std;
inline int read(){
char ch = getchar();
int a = 0,b = 1;
while(ch < '0' || ch > '9'){
if(ch == '-'){
b = -1;
}
ch = getchar();
}
while(ch >= '0' && ch <= '9'){
a = a * 10 + ch - '0';
ch = getchar();
}
return a * b;
}
typedef struct node{
char r;
char l;
}node;
node nodes[500];
void qianxu(char c){
cout << c;
if(nodes[c].l != '*'){
qianxu(nodes[c].l);
}
if(nodes[c].r != '*'){
qianxu(nodes[c].r);
}
}
int main()
{
ios::sync_with_stdio(false);
int n;
cin >> n;
char h;
for(int i = 0; i < n; i++){
char t;
cin >> t;
if(i == 0){
h = t;
}
cin >> nodes[t].l>>nodes[t].r;
}
qianxu(h);
return 0;
}
7、求先序排列
题目描述
给出一棵二叉树的中序与后序排列。求出它的先序排列。（约定树结点用不同的大写字母表示，长度≤8）。
输入格式
2行，均为大写字母组成的字符串，表示一棵二叉树的中序与后序排列。
输出格式
1行，表示一棵二叉树的先序。
输入输出样例
输入 #1
BADC
BDCA
输出 #1
ABCD
考察知识点：二叉树的遍历
这道题结合之前的两道遍历题，让我们彻底弄明白了三种遍历之间的关系，难度也不大，可以作为巩固的练手题，直接上代码。
AC code
#include <iostream>
#include <bits/stdc++.h>
#pragma GCC optimize(2)
#define ull unsigned long long
#define ll long long
using namespace std;
inline int read(){
char ch = getchar();
int a = 0,b = 1;
while(ch < '0' || ch > '9'){
if(ch == '-'){
b = -1;
}
ch = getchar();
}
while(ch >= '0' && ch <= '9'){
a = a * 10 + ch - '0';
ch = getchar();
}
return a * b;
}
string s1,s2;
void qian(int x, int y, int a, int b){
if(x > y || a > b){
return;
}
cout << s2[y];
int t = s1.find(s2[y]);
qian(x,x + t - 1 - a, a, t - 1);
qian(x+t - a,y - 1,t+1,b);
}
int main()
{
ios::sync_with_stdio(false);
cin >> s1 >>s2;
int l = s1.length();
qian(0,l-1,0,l-1);
return 0;
}
8、二叉树问题
题目描述
如下图所示的一棵二叉树的深度、宽度及结点间距离分别为：
深度：4 宽度：4（同一层最多结点个数）
结点间距离： ⑧→⑥为8 (3×2+2=8)
⑥→⑦为3 （1×2+1=3）
注：结点间距离的定义：由结点向根方向（上行方向）时的边数×2，
与由根向叶结点方向（下行方向）时的边数之和。
输入格式
输入文件第一行为一个整数n(1≤n≤100)，表示二叉树结点个数。接下来的n-1行，表示从结点x到结点y（约定根结点为1），最后一行两个整数u、v，表示求从结点u到结点v的距离。
输出格式
三个数，每个数占一行，依次表示给定二叉树的深度、宽度及结点u到结点v间距离。
输入输出样例
输入 #1
10
1 2
1 3
2 4
2 5
3 6
3 7
5 8
5 9
6 10
8 6
输出 #1
4
4
8
考察知识点：二叉树的概念 二叉树的遍历
这道题其实可以分为三个问题，分别是求二叉树的深度，二叉树的宽度，和在某种定义下的二叉树两个节点的距离。首先深度是我们之前就求过的，而宽度其实可以理解为同一深度的结点个数，所以我们开一个数组在求深度的同时记录一下宽度即可。两点之间距离是比较有意思的一个问题，我想到的解决方法是让深度更大的结点向上爬，直到找到两个结点的最近公共祖先。
AC code
#include <iostream>
#include <bits/stdc++.h>
using namespace std;
int de;//最大深度
int le;//最大宽度
int d[1000];//每个结点的深度
int l[1000];//每个结点的宽度
int fa[1000];//每个结点的父亲结点
int res = 0;//储存距离
//让两个结点不断向上爬的函数
void f(int n1,int n2){
if(n1 == n2){
return;
}
if(d[n1] > d[n2]){
res += 2;
f(fa[n1],n2);
}
else{
res+=1;
f(n1,fa[n2]);
}
}
int main()
{
ios::sync_with_stdio(false);
int N;
cin >> N;
d[1] = 1;
l[1] = 1;
de = 1;
le = 1;
for(int i = 1;i < N; i++){
int f,s;
cin >> f >> s;
d[s] = d[f] + 1;
l[d[s]]++;
le = max(le,l[d[s]]);
fa[s] = f;
}
for(int i = 1 ; i < N; i++){
if(d[i] > de){
de = d[i];
}
}
int n1,n2;
cin >> n1 >>n2;
cout << de<<endl;
cout << le<<endl;
f(n1,n2);
cout<<res<<endl;
return 0;
}
9、绘制二叉树
题目描述
二叉树是一种基本的数据结构，它要么为空，要么由根节点，左子树和右子树组成，同时左子树和右子树也分别是二叉树。
当一颗二叉树高度为m−1时，则共有m层。除m层外，其他各层的结点数都达到最大，且结点节点都在第mm*层时，这就是一个满二叉树。
现在，需要你用程序来绘制一棵二叉树，它由一颗满二叉树去掉若干结点而成。对于一颗满二叉树，我们需要按照以下要求绘制：
1、结点用小写字母“o”表示，对于一个父亲结点，用“/”连接左子树，同样用“\”连接右子树。
2、定义[i,j[i,j]为位于第ii行第jj列的某个字符。若[i,j][i,j]为“/”，那么[i-1,j+1][i−1,j+1]与[i+1,j-1][i+1,j−1]要么为“o”，要么为“/”。若[i,j][i,j]为“\”，那么[i-1,j-1][i−1,j−1]与[i+1,j+1][i+1,j+1]要么为“o”，要么为“\”。同样，若[i,j][i,j]为第1−m层的某个节点（即“o”），那么[i+1,j-1][i+1,j−1]为“/”，[i+1,j+1][i+1,j+1]为“\”。
3、对于第mm层节点也就是叶子结点，若两个属于同一个父亲，那么它们之间由3由3个空格隔开，若两个结点相邻但不属于同一个父亲，那么它们之间由11个空格隔开。第mm层左数第11个节点之前没有空格。
最后需要在一颗绘制好的满二叉树上删除n*个结点（包括它的左右子树，以及与父亲的连接），原有的字符用空格替换（ASCII 32，请注意空格与ASCII 0的区别(若用记事本打开看起来是一样的，但是评测时会被算作错误答案！)）。
输入格式
第1行包含2个正整数m和n，为需要绘制的二叉树层数已经从m层满二叉树中删除的结点数。
接下来n行，每行两个正整数，表示第ii层第jj个结点需要被删除（1<i≤M*,j≤2*i−1）。
输出格式
按照题目要求绘制的二叉树。
输入输出样例
输入 #1复制
2 0
输出 #1复制
o
/ \
o o
输入 #2复制
4 0
输出 #2复制
o
/ \
/ \
/ \
/ \
/ \
o o
/ \ / \
/ \ / \
o o o o
/ \ / \ / \ / \
o o o o o o o o
输入 #3复制
4 3
3 2
4 1
3 4
输出 #3复制
o
/ \
/ \
/ \
/ \
/ \
o o
/ /
/ /
o o
\ / \
o o o
说明/提示
30%30%的数据满足：n*=0；
50%50%的数据满足：2≤m≤5；
100%100%的数据满足：2≤m≤10,0≤n≤10。
考察知识点：二叉树的绘制
这道题没有设置太多的难点，就是让我们绘制一个二叉树，作为第一阶段学习的最后一道题，绘制一个二叉树是挺棒的结束。绘制的时候首先要声明一个字符型二维数组来作为画布，然后通过找规律，找到每个点的坐标，以及树枝的数量和层数的关系（见代码），然后再把不需要绘制的点用二维数组存起来，绘制的时候见到这些点就跳过。
AC code
#include <iostream>
#include <bits/stdc++.h>
using namespace std;
char mp[9999][9999];
int key[600];
bool node[9999][9999];
void drawmap(int x, int y, int m,int p , int q){
if(node[p][q] == 1){
return;
}
mp[x][y] = 'o';
if(m <= 1){
return;
}
if(m > 1){
for(int i = 1; i <= key[m]; i++){
if(node[p+1][q*2-1] != 1){
mp[x - i][y + i] = '/';
}
if(node[p+1][q*2] != 1){
mp[x + i][y + i] = '\\';
}
}
drawmap(x - key[m]-1, y + key[m]+1, m - 1,p+1,q*2-1);
drawmap(x + key[m]+1, y + key[m]+1, m - 1,p+1,q*2);
}
}
int main()
{
for(int i = 1; i <= 3000; i++){
for(int j = 1; j <= 3000; j++){
mp[i][j] = ' ';
node[i][j] = 0;
}
}
key[1] = 0;
key[2] = 1;
key[3] = 2;
int m,n;
cin >> m>>n;
for(int i = 4 ; i <= 300; i++){
key[i] = key[i - 1] * 2 + 1;
}
int x = 0;
for(int i = 1; i <= m; i++){
x += key[i] + 1;
}
for(int i = 0; i < n; i++){
int a,b;
cin >> b >> a;
node[b][a] = 1;
}
drawmap(x,1,m,1,1);
for(int i = 1; i < x * 2; i++){
for(int j = 1 ; j < x * 2; j++){
cout << mp[j][i];
}
cout << endl;
}
return 0;
}
小结✿✿ヽ(°▽°)ノ✿
这是我第一次写这种博客，确实有很多不足，比如题目难度的梯度，对题目的讲解等等，但我还是希望能通过这种方式，给别人带来一些思路。还有就是接下来可能会换一些方向，因为这周遇到了一些挺有意思的算法问题，下周可能会找一个算法专题写一写，但数据结构，尤其是树这个方向还是我接下来的重点之一。下周见ヾ(￣▽￣)ByeBye