PTA 21级数据结构与算法实验5——树和二叉树

7-1 还原二叉树

给定一棵二叉树的先序遍历序列和中序遍历序列，要求计算该二叉树的高度。

输入格式:

输入首先给出正整数N（≤50），为树中结点总数。下面两行先后给出先序和中序遍历序列，均是长度为N的不包含重复英文字母（区别大小写）的字符串。

输出格式:

输出为一个整数，即该二叉树的高度。

输入样例:

9
ABDFGHIEC
FDHGIBEAC

输出样例:

5

#include<stdio.h>
#include<stdlib.h>
typedef struct tree
{
    char data;
    struct tree *left,*right;
}tree;
int treeheight(tree *root)//求树的高度
{
    if(root==NULL)
        return 0;
    else
    {
        int len1=treeheight(root->left);
        int len2=treeheight(root->right);
        return len1>len2?len1+1:len2+1;
    }
}
tree* createtree(char *pre,char *in,int n)//建立树，pre是先序输入的，in是中序输入
{
    tree *root;
    root=(tree *)malloc(sizeof(struct tree));
    if(n==0)
        return NULL;
    int i;
    root->data=pre[0];
    for(i=0;i<n;i++)
        if(in[i]==root->data)
            break;
    root->left=createtree(pre+1,in,i);
    root->right=createtree(pre+i+1,in+i+1,n-i-1);
    return root;
}
int main()
{
    int n;
    scanf("%d",&n);
    char str1[n];
    char str2[n];
    scanf("%s%s",str1,str2);
    char *pre=str1;
    char *in=str2;
    tree *root=createtree(pre,in,n);
    printf("%d",treeheight(root));
    return 0;
}

7-2 朋友圈

某学校有N个学生，形成M个俱乐部。每个俱乐部里的学生有着一定相似的兴趣爱好，形成一个朋友圈。一个学生可以同时属于若干个不同的俱乐部。根据“我的朋友的朋友也是我的朋友”这个推论可以得出，如果A和B是朋友，且B和C是朋友，则A和C也是朋友。请编写程序计算最大朋友圈中有多少人。

输入格式:

输入的第一行包含两个正整数N（≤30000）和M（≤1000），分别代表学校的学生总数和俱乐部的个数。后面的M行每行按以下格式给出1个俱乐部的信息，其中学生从1~N编号：

第i个俱乐部的人数Mi（空格）学生1（空格）学生2 … 学生Mi

输出格式:

输出给出一个整数，表示在最大朋友圈中有多少人。

输入样例:

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

输出样例:

4

#include<bits/stdc++.h>
#define N 30003
using namespace std;
int family[N];//朋友数组
int find(int x)//查找函数
{
	if(x==family[x])
		return x;
	return family[x]=find(family[x]);
}
void merg(int x,int y)//并集
{
	family[find(y)] = family[x] ;
}
int main()
{  
	int i,j,n,m,kn;
	scanf("%d %d",&n,&m);
	for(i=1;i<=n;i++)
		family[i]=i;//记录所有学生的编号
	for(i=0;i<m;i++)
	{
		scanf("%d",&kn);
		int tmp1,tmp2;
		if(kn!=0);
			scanf("%d",&tmp1);
		for(j=1;j<kn;j++)
		{
			scanf("%d",&tmp2);
			if(find(tmp1) != find(tmp2)) // 这句判断不能少 否则错误
				merg(tmp1,tmp2);//查找并集
		}
	}
	int maxx=0 ;
	map<int,int>mp;
	for(i = 1;i <= n ; i++)
	{
		mp[find(i)] ++ ;
		if(mp[find(i)] > maxx)
		{
			maxx = mp[find(i)];
		}
	}
	printf("%d\n",maxx);
    return 0 ;  
}

 7-3 修理牧场

农夫要修理牧场的一段栅栏，他测量了栅栏，发现需要N块木头，每块木头长度为整数Li​个长度单位，于是他购买了一条很长的、能锯成N块的木头，即该木头的长度是Li​的总和。

但是农夫自己没有锯子，请人锯木的酬金跟这段木头的长度成正比。为简单起见，不妨就设酬金等于所锯木头的长度。例如，要将长度为20的木头锯成长度为8、7和5的三段，第一次锯木头花费20，将木头锯成12和8；第二次锯木头花费12，将长度为12的木头锯成7和5，总花费为32。如果第一次将木头锯成15和5，则第二次锯木头花费15，总花费为35（大于32）。

请编写程序帮助农夫计算将木头锯成N块的最少花费。

输入格式:

输入首先给出正整数N（≤104），表示要将木头锯成N块。第二行给出N个正整数（≤50），表示每段木块的长度。

输出格式:

输出一个整数，即将木头锯成N块的最少花费。

输入样例:

8
4 5 1 2 1 3 1 1

输出样例:

49

//哈夫曼树
#include<bits/stdc++.h>
using namespace std;
int main(){
    priority_queue <int,vector<int>,greater<int> > q;//优先队列 按照由小到大顺序
    int N,i,j,k,a[10000],d[10000],sum=0;
    scanf("%d",&N);
    for(i=0;i<N;i++)
    {
        scanf("%d",&a[i]);
    }
    for(i=0;i<N;i++)
    {
        q.push(a[i]);//将a[i]放入q队列中
    }
    while(!q.empty()&&q.size()!=1)//q队列不为空切长度不为1
    {
        int temp1= q.top();//先访问 再弹出 
        q.pop();
        int temp2= q.top();
        q.pop();
        int temp=temp1+temp2;
        sum+=temp;
        q.push(temp);
    }  
    printf("%d",sum);
}

7-4 玩转二叉树

给定一棵二叉树的中序遍历和前序遍历，请你先将树做个镜面反转，再输出反转后的层序遍历的序列。所谓镜面反转，是指将所有非叶结点的左右孩子对换。这里假设键值都是互不相等的正整数。

输入格式：

输入第一行给出一个正整数N（≤30），是二叉树中结点的个数。第二行给出其中序遍历序列。第三行给出其前序遍历序列。数字间以空格分隔。

输出格式：

在一行中输出该树反转后的层序遍历的序列。数字间以1个空格分隔，行首尾不得有多余空格。

输入样例：

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

输出样例：

4 6 1 7 5 3 2

#include<bits/stdc++.h>
using namespace std;
const int N = 50;
int in[N],pre[N],level[100000];
int cnt = 0;
int n;
void dfs(int root, int start, int end, int index)
{
	if(start > end) return;
	int i = start;
	while(i < end && in[i] != pre[root]) i++;
	level[index] = pre[root];
	dfs(root + 1, start, i - 1, 2 * index + 2);//这里将结点换位置，将左边和右边结点换位置。
	dfs(root + (i - start + 1), i + 1, end, 2 * index + 1);
}
int main()
{
	scanf("%d",&n);
	memset(level, -1, sizeof level);
	for(int i=0;i<n;i++) scanf("%d",&in[i]);
	for(int i=0;i<n;i++) scanf("%d",&pre[i]);
	dfs(0,0,n-1,0);
	for(int i=0;i<10000;i++)
    {
		if(level[i] != -1 && cnt != n - 1)
        {
			printf("%d ",level[i]);
			cnt++;
		}
        else if(level[i] != -1)
        {
			printf("%d",level[i]);
			break;
		}
	}
	return 0;
} 

7-5 根据后序和中序遍历输出先序遍历

本题要求根据给定的一棵二叉树的后序遍历和中序遍历结果，输出该树的先序遍历结果。

输入格式:

第一行给出正整数N(≤30)，是树中结点的个数。随后两行，每行给出N个整数，分别对应后序遍历和中序遍历结果，数字间以空格分隔。题目保证输入正确对应一棵二叉树。

输出格式:

在一行中输出Preorder: 以及该树的先序遍历结果。数字间有1个空格，行末不得有多余空格。

输入样例:

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

输出样例:

Preorder: 4 1 3 2 6 5 7

#include<bits/stdc++.h>
using namespace std;
int p[30+5];
int q[30+5];
int hash_temp[30+5];
int k,num[30+5];
int temp;
void fun(int lenth, int top_p, int top_q) {
    if(lenth < 1) return ;
    num[k++] = p[top_p + lenth - 1];
    temp = p[top_p + lenth - 1];
    int len = hash_temp[temp]-top_q;
    fun(len, top_p, top_q);
    fun(lenth - len - 1, top_p + len, top_q + len + 1); 
}
int main() 
{
    int len;
    cin>>len;
    k=0;
    for(int i = 0; i < len; i++) 
    {
        cin>>p[i];
    }
    for(int i = 0; i < len; i++) 
    {
        cin>>q[i];
        hash_temp[q[i]] = i;
    }
    fun(len, 0, 0);
    cout<<"Preorder: ";
    for(int i = 0; i < len - 1; i++) 
    {
        cout<<num[i]<<' ';
    }
    cout<<num[len-1];
    return 0;
}

 7-6 完全二叉树的层序遍历

一个二叉树，如果每一个层的结点数都达到最大值，则这个二叉树就是完美二叉树。对于深度为 D 的，有 N 个结点的二叉树，若其结点对应于相同深度完美二叉树的层序遍历的前 N 个结点，这样的树就是完全二叉树。

给定一棵完全二叉树的后序遍历，请你给出这棵树的层序遍历结果。

输入格式：

输入在第一行中给出正整数 N（≤30），即树中结点个数。第二行给出后序遍历序列，为 N 个不超过 100 的正整数。同一行中所有数字都以空格分隔。

输出格式：

在一行中输出该树的层序遍历序列。所有数字都以 1 个空格分隔，行首尾不得有多余空格。

输入样例：

8
91 71 2 34 10 15 55 18

输出样例：

18 34 55 71 2 10 15 91

#include <bits/stdc++.h>

using namespace std;
#define ENDL '\n'
const int maxn = 1e6 + 10;

int n, cur;
int a[maxn], ans[maxn];

void dfs(int i) {
    if (i > n) return;
    dfs(i * 2);  //先填左子树
    dfs(i * 2 + 1);
    ans[i] = a[cur++];
}
int main() {
    cin >> n;
    for (int i = 1; i <= n; i++) cin >> a[i];
    cur = 1;
    dfs(1);
    cout << ans[1];
    for (int i = 2; i <= n; i++) cout << " " << ans[i];
    cout << ENDL;
    return 0;
}

7-7 列出叶结点

对于给定的二叉树，本题要求你按从上到下、从左到右的顺序输出其所有叶节点。

输入格式：

首先第一行给出一个正整数 N（≤10），为树中结点总数。树中的结点从 0 到 N−1 编号。随后 N 行，每行给出一个对应结点左右孩子的编号。如果某个孩子不存在，则在对应位置给出 "-"。编号间以 1 个空格分隔。

输出格式：

在一行中按规定顺序输出叶节点的编号。编号间以 1 个空格分隔，行首尾不得有多余空格。

输入样例：

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

输出样例：

4 1 5

#include <iostream>
#include <cstdio>
using namespace std;

struct Node
{
	int data;	
	int left;
	int right;
};
int main()
{
	int n;
	cin >> n;
	getchar();  //getchar(),吞掉回车
	Node tree[15];   //因为这个数组的下标就是data，所以我不需要额外的data域
	int checked[15] = {};   //检查根节点的
	for(int i = 0;i < n;i++)
	{
		char l,r;	
		scanf("%c %c",&l,&r);
		getchar();  
		if(l == '-')tree[i].left = -1;
		else
		{
			tree[i].left = (l - '0');
			checked[l - '0'] = 1;
		}
		if(r == '-')tree[i].right = -1;
		else
		{
			tree[i].right = (r - '0');
			checked[r - '0'] = 1;
		}
	}
	int ans[15] = {};
	for(int i = 0;i < n;i++)
	{
		if(checked[i] == 0)
		{
			ans[0] = i;	//在这里找到了根节点，存进队列去了
			break;
		}
	}
	int k = 1;  //注意一下,k是从 1 开始的
	for(int i = 0;i < n;i++) 
	{
		if(tree[ans[i]].left != -1)ans[k++] = tree[ans[i]].left;	
		if(tree[ans[i]].right != -1)ans[k++] = tree[ans[i]].right;	
	}
	int flag = 0;
	for(int i = 0;i < n;i++)
	{
		if(tree[ans[i]].left == -1 && tree[ans[i]].right == -1)
		{
			if(flag)cout << " ";	
			flag = 1;
			cout << ans[i];
		}
	}
	return 0;
}

7-8 部落

在一个社区里，每个人都有自己的小圈子，还可能同时属于很多不同的朋友圈。我们认为朋友的朋友都算在一个部落里，于是要请你统计一下，在一个给定社区中，到底有多少个互不相交的部落？并且检查任意两个人是否属于同一个部落。

输入格式：

输入在第一行给出一个正整数N（≤104），是已知小圈子的个数。随后N行，每行按下列格式给出一个小圈子里的人：

K P[1] P[2] ⋯ P[K]

其中K是小圈子里的人数，P[i]（i=1,⋯,K）是小圈子里每个人的编号。这里所有人的编号从1开始连续编号，最大编号不会超过104。

之后一行给出一个非负整数Q（≤104），是查询次数。随后Q行，每行给出一对被查询的人的编号。

输出格式：

首先在一行中输出这个社区的总人数、以及互不相交的部落的个数。随后对每一次查询，如果他们属于同一个部落，则在一行中输出Y，否则输出N。

输入样例：

4
3 10 1 2
2 3 4
4 1 5 7 8
3 9 6 4
2
10 5
3 7

输出样例：

10 2
Y
N

#include <bits/stdc++.h>
using namespace std;

const int maxn = 1e4 + 10;
int father[maxn];

int find(int x) {
	if(x == father[x])	return x;
	else {
		father[x] = find(father[x]);
		return father[x];
	}
}

void merge(int x, int y) {
	int fx = find(x);
	int fy = find(y);
	father[fy] = fx;
}

int main() {
	int n;
	cin >> n;
	set<int>s;
	int data, sum, fir, ans1 = 0, ans2 = 0;
	for(int i = 0; i < maxn; i++)	father[i] = i;
	for(int i = 1; i <= n; i++) {
		cin >> sum ;
		if(sum > 0)	cin >> fir, s.insert(fir);
		for(int i = 1; i < sum; i++) {
			cin >> data;
			s.insert(data);
			merge(fir, data);
		}
	}
	
	ans1 = s.size();
	for(int i = 1; i <= ans1; i++)	if(father[i] == i)	ans2++;
	cin >> n;
	int x, y;
	cout << ans1 << " " << ans2 << endl;
	for(int i = 1; i <= n; i++) {
		cin >> x >> y;
		if(find(x) == find(y))	cout << 'Y' << endl;
		else	cout << 'N' << endl; 
	} 
	return 0;
} 

7-9 建立与遍历二叉树

以字符串的形式定义一棵二叉树的先序序列，若字符是‘#’, 表示该二叉树是空树，否则该字符是相应结点的数据元素。读入相应先序序列，建立二叉链式存储结构的二叉树，然后中序遍历该二叉树并输出结点数据。

输入格式:

字符串形式的先序序列（即结点的数据类型为单个字符）

输出格式:

中序遍历结果

输入样例:

在这里给出一组输入。例如：

ABC##DE#G##F###

输出样例:

在这里给出相应的输出。例如：

CBEGDFA

#include<stdio.h>
#include<string.h>
#include<malloc.h>
typedef struct tree
{
	char data;
	struct tree *left;
	struct tree *right;
}tree;
char ch[10005];
int i=0;
tree *creat()
{
	char op=ch[i++];
	if(op=='#') 
        return NULL;
	tree *root;
    root=(tree*)malloc(sizeof(tree));
	root->data=op;
	root->left=creat();
	root->right=creat();
	return root;
}
void InorderTraversal(tree *root)//中序遍历，先遍历左子树，再输出根节点，再遍历右子树
{//（左子树->根->右子树)
	if(root==NULL) 
    {
		return ;
	}
    InorderTraversal(root->left);
	printf("%c",root->data);
	InorderTraversal(root->right);
}//中序可以记为：空返回空，左递归，输出，右递归；
int main()
{
	scanf("%s",ch);
	tree *root;
    root=creat();
	InorderTraversal(root);
	return 0;
}

7-10 交换二叉树中每个结点的左孩子和右孩子

以二叉链表作为二叉树的存储结构，交换二叉树中每个结点的左孩子和右孩子。

输入格式:

输入二叉树的先序序列。

提示：一棵二叉树的先序序列是一个字符串，若字符是‘#’,表示该二叉树是空树，否则该字符是相应结点的数据元素。

输出格式:

输出有两行：

第一行是原二叉树的中序遍历序列；

第二行是交换后的二叉树的中序遍历序列。

输入样例:

ABC##DE#G##F###

输出样例:

CBEGDFA

AFDGEBC

#include <iostream>
using namespace std;

typedef struct Node {
    char data;
    struct Node *left, *right;
} Node, *Tree;

Tree create() {
    char ch;
    Tree tree = NULL;
    if (scanf("%c", &ch)) {//当有输入时
        if (ch != '#') {
            tree = (Tree)malloc(sizeof(Node));
            tree->data = ch;
            tree->left = create();
            tree->right = create();
        } else {
            tree = NULL;
        }
    }
    return tree;
}

void order(Tree tree) {
    if (!tree)
        return;
    order(tree->left);
    printf("%c", tree->data);
    order(tree->right);
}

void swap(Tree tree) {
    if (!tree)
        return;
    if (!tree->left && !tree->right)
        return;
    Tree tmp = tree->left;
    tree->left = tree->right;
    tree->right = tmp;
    swap(tree->left);
    swap(tree->right);
}

int main() {
    Tree tree = create();
    order(tree);
    cout << endl;
    swap(tree);
    order(tree);
    return 0;
}

7-11 树的遍历

给定一棵二叉树的后序遍历和中序遍历，请你输出其层序遍历的序列。这里假设键值都是互不相等的正整数。

输入格式：

输入第一行给出一个正整数N（≤30），是二叉树中结点的个数。第二行给出其后序遍历序列。第三行给出其中序遍历序列。数字间以空格分隔。

输出格式：

在一行中输出该树的层序遍历的序列。数字间以1个空格分隔，行首尾不得有多余空格。

输入样例：

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

输出样例：

4 1 6 3 5 7 2

#include <stdio.h>
int s[31],c[31],l,i，M[31];
//第一步：如果数组大小为零的话，说明是空了
//第二步：如果数组不为空，那么找后序数组最后一个元素
//第三步：找到后序数组最后一个元素在中序数组的位置，作为切割点
//第四步：切割中序数组，切成中序左数组和中序右数组
//第五步：切割后序数组，切成后序左数组和后序右数组
//第六步：递归处理左区间和右区间
void la(int l,int r,int st,int ed,int f)
{
    if(l<=r&&st<=ed)
    {
        M[f]=c[ed];
        for(int i=l; i<=r; i++)
            if(c[ed]==s[i])
            {
                la(l,i-1,st,st+i-1-l,2*f+1),la(i+1,r,st+i-l,ed-1,2*f+2);
                return ;
            }
    }
}
int main()
{
    scanf("%d",&l);
    for(i=0;i<l;i++)
        scanf("%d",&c[i]);
    for(i=0;i<l;i++)
        scanf("%d",&s[i]);
    la(0,l-1,0,l-1,0);
    int f=0;
    for(auto X:M)
    {
        if(f)
            printf(" ");
        printf("%d",X.second);
        f+1;
    }
    return 0;
}

 c语言战士的落幕