数据结构第二次上机实验代码

数据结构第二次实验（二叉树）

满二叉树的前序遍历

题目描述

给你一个满二叉树的层次遍历序列，请编程输出该二叉树的前序遍历序列。

输入

第一行是n（n小于26）,表示有n个节点。第二行是该满二叉树的节点对应字母的层次遍历序列。

输出

输出该满二叉数的前序遍历序列。

样例输入 Copy

1
2
3
B A C

样例输出 Copy

1
BAC
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
//满二叉树的前序遍历
#include<bits/stdc++.h>
using namespace std;
int n;
char a[30];
void predfs(int x){
    if(a[x]){
        cout<<a[x];
        predfs(2*x);
        predfs(2*x+1);
    }
}
int main(){
    cin>>n;
    for(int i=1;i<=n;i++) cin>>a[i];
    predfs(1);
}

满二叉树的中序遍历

题目描述

给你一个满二叉树的层次遍历序列，请编程输出该二叉树的中序遍历序列。

输入

第一行是n（n小于26）,表示有n个节点。第二行是该满二叉树的节点对应字母的层次遍历序列。

输出

输出该满二叉数的中序遍历序列。

样例输入 Copy

1
2
3
B A C

样例输出 Copy

1
ABC
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
//满二叉树的中序遍历
#include<bits/stdc++.h>
using namespace std;
int n;
char a[30];
void predfs(int x){
    if(a[x]){
        predfs(2*x);
        cout<<a[x];
        predfs(2*x+1);
    }
}
int main(){
    cin>>n;
    for(int i=1;i<=n;i++) cin>>a[i];
    predfs(1);
}

满二叉树的后序遍历

题目描述

给你一个满二叉树的层次遍历序列，请编程输出该二叉树的后序遍历序列。

输入

第一行是n（n小于26）,表示有n个节点。第二行是该满二叉树的节点对应字母的层次遍历序列。

输出

输出该满二叉数的后序遍历序列。

样例输入 Copy

1
2
3
B A C

样例输出 Copy

1
ACB
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
//满二叉树的后序遍历
#include<bits/stdc++.h>
using namespace std;
int n;
char a[30];
void predfs(int x){
    if(a[x]){
        predfs(2*x);
        predfs(2*x+1);
        cout<<a[x];
    }
}
int main(){
    cin>>n;
    for(int i=1;i<=n;i++) cin>>a[i];
    predfs(1);
}

任意二叉树的前序遍历

题目描述

有若干个节点，每个节点上都有编号，把这些节点随意地构成二叉树，请编程输出该二叉树的前序遍历序列。

输入

第一行是n（n小于100）,表示有n个节点，每个节点按从1到n依次编号。第一行后有n行，每行三个正整数i、l、r，分别表示节点i及对应的左右孩子的编号，如果不存在孩子则以-1表示。三个整数之间用一个空格隔开。

输出

输出该二叉数的前序遍历序列。

样例输入 Copy

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

样例输出 Copy

1
3 1 2 4
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
//任意二叉树的前序遍历
#include <bits/stdc++.h>
using namespace std;
int n;//结点个数
struct A{
    int data;
    A *l;
    A *r;
    A *fa;
}BTree[105];
void predfs(A *X){
    if(X!=NULL){
        cout<<X->data<<' ';
        predfs(X->l);
        predfs(X->r);
    }//前序遍历：根左右
}
int main(){
    cin>>n;
    int a,b,c;
    for(int i=1;i<=n;i++)
    {
        BTree[i].data=i;
        BTree[i].fa=NULL;
        BTree[i].l=NULL;
        BTree[i].r=NULL;
    }
    for(int i=1;i<=n;i++)
    {
        cin>>a>>b>>c;
        if(b!=-1)
        {
            BTree[a].l=BTree+b;
            BTree[b].fa=BTree+a;
        }
        if(c!=-1)
        {
            BTree[a].r=BTree+c;
            BTree[c].fa=BTree+a;
        }
    }

    int pos;
    for(int i=1;i<=n;i++)
    {
        if(BTree[i].fa==NULL)
        {
            pos=i;
            break;
        }
    }
    predfs(BTree+pos);
    return 0;	
}

任意二叉树的中序遍历

题目描述

有若干个节点，每个节点上都有编号，把这些节点随意地构成二叉树，请编程输出该二叉树的中序遍历序列。

输入

第一行是n（n小于100）,表示有n个节点，每个节点按从1到n依次编号。第一行后有n行，每行三个正整数i、l、r，分别表示节点i及对应的左右孩子的编号，如果不存在孩子则以-1表示。三个整数之间用一个空格隔开。

输出

输出该二叉数的中序遍历序列。

样例输入 Copy

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

样例输出 Copy

1
2 1 4 3
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
#include <bits/stdc++.h>
using namespace std;
int n;
struct A{
    int data;//结点的值
    A *l;
    A *r;
    A *fa;//结点的父亲
}BTree[105];//A类型的数组
void predfs(A *X){
    if(X!=NULL){
        predfs(X->l);
        cout<<X->data<<' ';
        predfs(X->r);
    }
}//根左右
int main(){
    cin>>n;
    int a,b,c;//a是序号 b是左孩子 c是右孩子
    for(int i=1;i<=n;i++)
    {
        BTree[i].data=i;
        BTree[i].fa=NULL;
        BTree[i].l=NULL;
        BTree[i].r=NULL;
    }//给四个结点初始化
    for(int i=1;i<=n;i++)
    {
        cin>>a>>b>>c;
        if(b!=-1)//有左孩子
        {
            BTree[a].l=BTree+b;
            BTree[b].fa=BTree+a;
        }
        if(c!=-1)//有右孩子
        {
            BTree[a].r=BTree+c;
            BTree[c].fa=BTree+a;
        }
    }

    int pos;//找出初始结点
    for(int i=1;i<=n;i++)
    {
        if(BTree[i].fa==NULL)
        {
            pos=i;
            break;
        }
    }
    predfs(BTree+pos);
    return 0;	
}

任意二叉树的后序遍历

题目描述

有若干个节点，每个节点上都有编号，把这些节点随意地构成二叉树，请编程输出该二叉树的后序遍历序列。

输入

第一行是n（n小于100）,表示有n个节点，每个节点按从1到n依次编号。第一行后有n行，每行三个正整数i、l、r，分别表示节点i及对应的左右孩子的编号，如果不存在孩子则以-1表示。三个整数之间用一个空格隔开。

输出

输出该二叉数的后序遍历序列。

样例输入 Copy

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

样例输出 Copy

1
2 4 1 3
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
#include <bits/stdc++.h>
using namespace std;
int n;
struct A{
    int data;
    A *l;
    A *r;
    A *fa;
}BTree[105];
void predfs(A *X){
    if(X!=NULL){
        predfs(X->l);
        predfs(X->r);
        cout<<X->data<<' ';
    }
}
int main(){
    cin>>n;
    int a,b,c;
    for(int i=1;i<=n;i++)
    {
        BTree[i].data=i;
        BTree[i].fa=NULL;
        BTree[i].l=NULL;
        BTree[i].r=NULL;
    }
    for(int i=1;i<=n;i++)
    {
        cin>>a>>b>>c;
        if(b!=-1)
        {
            BTree[a].l=BTree+b;
            BTree[b].fa=BTree+a;
        }
        if(c!=-1)
        {
            BTree[a].r=BTree+c;
            BTree[c].fa=BTree+a;
        }
    }

    int pos;
    for(int i=1;i<=n;i++)
    {
        if(BTree[i].fa==NULL)
        {
            pos=i;
            break;
        }
    }
    predfs(BTree+pos);
    return 0;	
}

满二叉树的深度

题目描述

给你一个满二叉树的层次遍历序列，请编程输出该二叉树的深度。

输入

第一行是n（n小于26）,表示有n个节点。第二行是该满二叉树的节点对应字母的层次遍历序列。

输出

输出该满二叉数的深度。

样例输入 Copy

1
2
3
B A C

样例输出 Copy

1
2
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
//满二叉树的深度
#include <bits/stdc++.h>
using namespace std;
int n;
char a[30];
int ans=1;
void predfs(int x){
    if(a[x]){
        ans=max(ans,int(log2(x)+1));//满二叉树的深度=log2(n)+1
        predfs(2*x);
        predfs(2*x+1);
    }
}
int main(){
    cin>>n;
    for(int i=1;i<=n;i++) cin>>a[i];
    predfs(1);
    cout<<ans;
    return 0;	
}

FBI树

题目描述

我们可以把由“0”和“1”组成的字符串分为三类：全“0”串称为 B 串，全“1”串称为 I 串，既含“0”又含“1”的串则称为 F 串。
FBI 树是一棵二叉树，它的结点类型也包括 F 结点，B 结点和 I 结点三种。由一个长度为 2N 的“01”串 S 可以构造出一棵 FBI 树 T，递归的构造方法如下：
(1) T 的根结点为 R，其类型与串 S 的类型相同；
(2) 若串 S 的长度大于 1，可将串 S 从中间分开，分为等长的左右子串 S1 和 S2；由左子串 S1 构造 R 的左子树 T1，由右子串 S2 构造 R 的右子树 T2。

现在给定一个长度为 2N 的“01”串，请用上述构造方法构造出一棵 FBI 树，并输出它的后序遍历序列。

输入

第一行是一个整数 N（0≤N≤10），第二行是一个长度为 2N 的“01”串。

输出

包括一行，这一行只包含一个字符串，即 FBI 树的后序遍历序列。

样例输入 Copy

1
2
3 
10001011

样例输出 Copy

1
IBFBBBFIBFIIIFF
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
#include <bits/stdc++.h>
using namespace std;
int n;
char a[1024];
char b[1024];
void judge(int l,int r,int pos){
    int x=0,y=0;
    for(int i=l;i<=r;i++){
        if(a[i]=='0') x++;
        else y++;
    }
    if(x==0 && y>0) b[pos]='I';
    else if(x>0 && y==0) b[pos]='B';
    else b[pos]='F';
    //cout<<b[pos]<<' ';
    if(l==r) return ;
    else{
        judge(l,(l+r)/2,2*pos);
        judge((l+r)/2+1,r,2*pos+1);
    }
}
void out(int x){
    if(b[x]){
        out(2*x);
        out(2*x+1);
        cout<<b[x];
    }
}
int main(){
    cin>>n;
    for(int i=1;i<=pow(2,n);i++) cin>>a[i];
    judge(1,pow(2,n),1);
    out(1);
    return 0;	
}// FBI
数据结构

本博客所有文章除特别声明外，均采用 CC BY-SA 4.0 协议 ，转载请注明出处！