数组模拟建立二叉树和树

最新推荐文章于 2026-02-15 22:07:13 发布

原创最新推荐文章于 2026-02-15 22:07:13 发布 · 2.1k 阅读

10 ·

本内容遵循CC 4.0 BY-SA版权协议

二叉搜索树专栏收录该内容

5 篇文章

订阅专栏

这篇博客介绍了如何根据完全二叉树的后序遍历建立层序遍历序列，以及如何通过先根序列建立二叉树和树，包括解决叶结点数据值和最大层的问题。还讨论了如何利用前序和中序遍历来构造二叉树，并涉及树的镜面反转和层序遍历。

1. 完全二叉树的建立

例题：完全二叉树的层序遍历

一个二叉树，如果每一个层的结点数都达到最大值，则这个二叉树就是完美二叉树。对于深度为 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<stdio.h>
#include<math.h>
#include<string.h>
#include<queue>
#include<algorithm>
#define INF 0x3f3f3f3f
using namespace std;
int tree[33];//用数组模拟树 
int a[33];
int book[100];
int n,m;//m是n的副本，不改变n的大小，改变m的大小 
void build(int idx)//完全二叉树的下标
{
	if(book[idx]==0)//证明该树上的改结点可以放值 
	{
		tree[idx]=a[m--];
		book[idx]=INF;//又不可以放了
	//	return; 
	}
	if(book[idx*2+1]==0)
		build(idx*2+1);
	if(book[idx*2]==0)	
		build(idx*2); 
}
int main()
{
	int i;
	while(~scanf("%d",&n))
	{
		m=n;
		memset(book,INF,sizeof(book));//树上的每一个结点都被标记成了无穷大，即该结点不能被放任何值 
		for(i=1;i<=n;i++)
		{
			scanf("%d",&a[i]);
			book[i]=0;//标记为0，证明可以放值了 
		}
		build(1);//构建完全二叉树
		for(i=1;i<=n;i++)
		{
			if(i==1)
				printf("%d",tree[i]);
			else
				printf(" %d",tree[i]);
		}
		printf("\n");
	}
	return 0;
}

2. 先根序列建立二叉树

例题：二叉树叶结点值和最大层

已知一棵非空二叉树结点的数据域为不等于0的整数，请编写程序找出该二叉树中叶结点数据值之和最大的层。

输入格式:
输入为一组用空格间隔的整数，个数不超过100个，表示带空指针信息的二叉树先根序列。

输出格式:
输出为一个整数，表示叶结点数据值之和最大的层，如果存在多个满足条件的层，则输出最下面一层。

输入样例1:

1 2 0 0 3 0 0

输出样例1

输入样例2:

1 -2 0 0 3 -1 0 0 -1 0 0

输出样例2:

题意：
——题意说的不是很明白，这里把样例图给大家，大家一看就明白了。

在这里插入图片描述
构图代码

#include<stdio.h>
#include<string.h>
#include<algorithm>
using namespace std;
const int N=110;
const int INF=0x3f3f3f3f;
int tree[4*N]; 
int book[4*N];
int a[N];
int n,m;
/*
book[i]==0表示是空，需填值
book[i]==1表示非空，已填值 
*/
void build(int idx)
{
	if(book[idx]==0)
	{
		if(a[++m]==0)//如果该数据值是零，就不存放到结点里了
			return;
		tree[idx]=a[m];
		book[idx]=1;
		n=max(n,idx);//可记录二叉树的末结点位置
	}
	build(idx*2);
	build(idx*2+1);
}
int main()
{
	n=0;	 
	int x,i;
	while(~scanf("%d",&x))
		a[++n]=x;
	m=0;
	n=0;
	memset(book,0,sizeof(book));
	build(1);
	for(i=1;i<=n;i++)
		printf("%d ",tree[i]);
	printf("%d\n",n);
	return 0;
}

在这里插入图片描述
问题来了：

该图不利于求解每层的叶结点数据值之和，因为对于一个结点，不仅要判断它是不是叶结点，同时还要判断处于哪一层，比较麻烦。
如果在建图的过程中记录一下该结点在哪一层就好了。其实开一个结构体搞定这个问题，结构体里面一个变量x表示结点内数值，一个变量h表示该结点处于的层数。

改善后的代码：

#include<stdio.h>
#include<string.h>
#include<algorithm>
using namespace std;
const int INF=0x3f3f3f3f;
const int N=110;
struct Node
{
	int x;
	int h;
}tree[4*N]; 
int book[4*N];
int a[N],sum[N]; 
int n,m;
/*
book[i]==0表示是空，需填值
book[i]==1表示非空，已填值 
*/
void build(int idx,int h)
{
	if(book[idx]==0)
	{
		book[idx]=1;
		tree[idx].x=a[++m];
		tree[idx].h=h;
		if(a[m]==0)//这里可以把数据0放到结点里面,
			return;//利于后续的判断
	}		
	build(idx*2,h+1);
	build(idx*2+1,h+1);
}
void front(int idx)
{
	while(tree[idx].x!=0)
	{
		if(tree[idx*2].x==0&&tree[idx*2+1].x==0)
			sum[tree[idx].h]+=tree[idx].x;
		front(idx*2);
		front(idx*2+1);
		break;
	}
}
int main()
{
	n=0;	 
	int x;
	while(~scanf("%d",&x))
		a[++n]=x;
	m=0;
	memset(book,0,sizeof(book));
	memset(sum,0,sizeof(sum));
	build(1,0);//建树
	front(1); //求解每一层叶结点之和。
	int i,maxx=-INF,xx=0;
	for(i=0;i<=10;i++)//一定不会超过10层的
	{
		if(maxx<=sum[i]&&sum[i]!=0)
		{
			maxx=sum[i];
			xx=i;
		}
	}
	printf("%d\n",xx);
	return 0;
}

3. 先根序列建立树

例题：树层次遍历

我们已知二叉树与其自然对应的树相比，二叉树中结点的左孩子对应树中结点的左孩子，二叉树中结点的右孩子对应树中结点的右兄弟。进而我们可以利用“基于带空指针信息的先根序列构建二叉树”的方法来构建其对应的树的左孩子-右兄弟存储结构。如8 5 1 0 6 0 2 0 0 3 4 0 0 7 0 0 0对应图1(a)所示的树，1 2 0 3 0 4 0 0 0对应如图1(b)所示的树。

在这里插入图片描述
注意：该题说的是树，树的结点可以有多个。

思路：
——开一个结构体数组，每一个结构体2个变量，k表示当前层结点的个数，数组a用来存放该层的结点数值。

代码：

#include<stdio.h>
#include<string.h>
#include<algorithm>	
using namespace std;
struct Node{
	int k;//表示当前层的结点个数 
	int a[110];//存放每一层的结点值 
}q[200];
int main()
{
	int i,j,x,maxx=0;
	for(i=1;i<=200;i++)
		q[i].k=0;
	int cnt=100;//为了防止cnt一直减，减到负数。 
	while(~scanf("%d",&x))
	{
		if(x!=0)
		{
			++cnt;//存到下一层 
			maxx=max(maxx,cnt);
			++q[cnt].k;
			q[cnt].a[q[cnt].k]=x;
		}
		else
			--cnt;//退回上一层 
	}
	//后序的0可能会有多个
	//会导致cnt减了许多不必要的 
	while(q[cnt].k==0) 
		++cnt;
	for(i=cnt;i<=maxx;i++)
	{
		for(j=1;j<=q[i].k;j++)
			printf("%d ",q[i].a[j]);
	}
	return 0;
}

4.（前序和中序构造二叉树）或者（后序和中序）构造二叉树

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

输入格式：
——输入第一行给出一个正整数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

题意：
——其实所谓的镜面反转，就是除根结点外的结点，左子树的变为右子树，右子树变为左子树。

——详细题解晚点再写，现提供代码。

代码1（适用于键值都是互不相等的正整数）：

#include<stdio.h>
#include<string.h>
#include<algorithm>
#include<queue>
using namespace std;
const int N=1100;
int in[N];    //存中序
int pre[N];   //存前序
int lch[N];   //存左子树
int rch[N];   //存右子树
int build(int l1,int r1,int l2,int r2)//递归建树，l1,r1代表中序，l2,r2代表后序 
{
	if(l1>r1)
    	return 0;
	int root=pre[l2];
	int p=l1;
	while(in[p]!=root)    p++;//找到根的位置 
	int cnt=p-l1;//表示根结点root的左孩子个数。 
	lch[root]=build(p+1,r1,l2+cnt+1,r2);//根据镜像原理，左子树会出现在中序的右边
	rch[root]=build(l1,p-1,l2+1,l2+cnt);//根据镜像原理，右子树会出现在中序的左边
	return root;
}
void bfs(int root)
{
	queue<int> Q;
	Q.push(root);
	int flag=0;
	while(!Q.empty())
	{
    	root=Q.front();
    	Q.pop();
    	if(flag)
        	printf(" %d",root);
    	else
        	printf("%d",root);
    	flag=1;
    	if(lch[root]!=0)
        	Q.push(lch[root]);
    	if(rch[root]!=0)
        	Q. push(rch[root]);
	}
	printf("\n");
}
int main()
{
	int n,i;
	scanf("%d",&n);
	for(i=1;i<=n;i++)
    	scanf("%d",&in[i]);
	for(i=1;i<=n;i++)
    	scanf("%d",&pre[i]);
	memset(lch,0,sizeof(lch));
	memset(rch,0,sizeof(rch));
	int root=build(1,n,1,n);
	bfs(root);
	return 0;
}

代码2：