二叉树的性质和常用操作代码集合

二叉树的性质和常用操作代码集合

性质：

二叉树的性质和常用代码操作集合

性质1:在二叉树的第i层上至多有$2^{i-1}$个结点

性质2：深度为k的二叉树至多有$2^k-1$个结点

性质3：对任意一棵二叉树T，若终端结点数为n0，而其度数为2的结点数为n2，则n0 = n2 + 1

满二叉树：深度为k且有$2^k-1$个结点的树
完全二叉树：深度为k，结点数为n的二叉树，如果其结点1~n的位置序号分别与等高的满二叉树的结
点1~n的位置序号一一对应，则为完全二叉树。

性质4：具有n的结点的完全二叉树深度为log2n + 1

性质5：对于具有n个结点的完全二叉树，如果按照从上到下和从左到右的顺序对二叉树中的所有结点
从1开始顺序编号，则对于任意的序号为i的结点有：
1.如i = 1，则序号为i的结点为根结点，无双亲结点；如i>1，则序号为i的结点的双亲结点序号为
i/2。
2.如2i>n，则序号为i的结点无左孩子;如2i<=n，则序号为i的结点的左孩子结点的序号为2i。
3.如2i+1>n，则序号为i的结点无右孩子，如2i+1<=n，则序号为i的结点的右孩子序号为2i+1。

1.宏定义：
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#define datatypebt char
#define MAXNODE 1024
#define BOTTOMNODE 1024
#define FULLNODE 1024
2.结构体：
typedef struct bitnode
{
	datatypebt data;
	struct bitnode *lchild,*rchild;
}Bitnode,*Bitree;
3.基本函数：
Bitree Initiate_Bitree()
/*初始化二叉树函数1.先决条件:无2.函数作用:初始化一棵空的带头结点的二叉树,返回头结点的地址*/
{
	Bitnode *bt;
	bt=(Bitnode *)malloc(sizeof(Bitnode));
	bt->lchild=NULL;
	bt->rchild=NULL;
	return bt;
}
Bitnode *Create_Bitree(datatypebt x,Bitnode *lbt,Bitnode *rbt)
/*建立二叉树函数1.先决条件:无2.函数作用:生成一棵以x为根结点数据域信息,以lbt,rbt为左右子树的二叉树,返回新二叉树的地址*/
{
	Bitree p;
	p=(Bitnode *)malloc(sizeof(Bitnode));
	p->data=x;
	p->lchild=lbt;
	p->rchild=rbt;
	return p;
}
void Precreate_Bitree(Bitree *T)
/*先序构建二叉树函数1.先决条件:T是子树根结点的地址2.函数作用:以先序遍历序列构造二叉树链表存储的二叉树T*/
{
	char ch;
	scanf("%c",&ch);
	if(ch=='0')
		*T=NULL;
	else
	{
		(*T)=(Bitnode *)malloc(sizeof(Bitnode));
		(*T)->data=ch;
		Precreate_Bitree(&(*T)->lchild);
		Precreate_Bitree(&(*T)->rchild);
	}
}
void Preinorder_Bitree(Bitree *t,char preod[],int i,int j,char inod[],int k,int h)
/*先中序恢复树函数1.先决条件:t是子树根结点的地址2.函数作用:preod[i..j]为先序子序列,inod[k..h]为中子序序列,根据先序序列和中序序列恢复二叉树t*/
{
	int m;
	*t=(Bitnode *)malloc(sizeof(Bitnode));
	(*t)->data=preod[i];
	m=k;
	while(inod[m]!=preod[i])
		m++;
	if(m==k)
		(*t)->lchild=NULL;
	else
		Preinorder_Bitree(&(*t)->lchild,preod,i+1,i+m-k,inod,k,m-1);
	if(m==h)
		(*t)->rchild=NULL;
	else
		Preinorder_Bitree(&(*t)->rchild,preod,i+m-k+1,j,inod,m+1,h);
}
int Recovery_Bitree(Bitree bt,char preod[],char inod[],int n)
/*先中序恢复树函数1.先决条件:初始化二叉树,bt为头结点,拥有Preinorder_Bitree()函数2.函数作用:根据先序和中序序列恢复二叉树bt,成功返回1*/
{
	if(n<=0)
		bt->lchild=NULL;
	else Preinorder_Bitree(&bt->lchild,preod,0,n-1,inod,0,n-1);
	return 1;
}
void Postfree_Bitree(Bitree p)
/*后序释放函数1.先决条件:p为子树根结点的地址2.函数作用:释放子树p的全部空间*/
{
	if(p==NULL)
		return ;
	Postfree_Bitree(p->lchild);
	Postfree_Bitree(p->rchild);
	free(p);
}
int Empty_Bitree(Bitree bt)
/*判空函数1.先决条件:初始化二叉树,bt为头结点2.函数作用:若二叉树bt为空,则返回1,否则返回0*/
{
	if(bt->lchild==NULL)
		return 1;
	else return 0;
}
Bitnode *Root_Bitree(Bitree bt)
/*求根函数1.先决条件:初始化二叉树,bt为头结点2.函数作用:求二叉树bt的根结点,返回根结点的地址,若bt为空二叉树,则函数返回NULL*/
{
	return bt->lchild;
}
Bitnode *Search_Bitree(Bitree bt,datatypebt x)
/*查找函数1.先决条件:初始化二叉树,bt是子树根或头结点2.函数作用:在二叉树bt中查找值为x的数据元素,成功返回其地址,找不到返回NULL*/
{
	Bitree p=NULL;
	if(bt)
	{
		if(bt->data==x)
			return bt;
		if(bt->lchild)
			p=Search_Bitree(bt->lchild,x);
		if(p)
			return p;
		if(bt->rchild)
			p=Search_Bitree(bt->rchild,x);
		if(p)
			return p;
	}
	return NULL;
}
int InsertL_Bitree(Bitnode *parent,datatypebt x)
/*左插入函数1.先决条件:无2.函数作用:在二叉树中的parent所指结点和其左子树之间插入数据元素为x的结点,成功返回1*/
{
	Bitnode *p;
	if(parent==NULL)
	{
		printf("插入出错.
");/*此句可以根据情况删除*/
		return 0;
	}
	p=(Bitnode *)malloc(sizeof(Bitnode));
	p->data=x;
	p->lchild=NULL;
	p->rchild=NULL;
	if(parent->lchild==NULL)
		parent->lchild=p;
	else
	{
		p->lchild=parent->lchild;
		parent->lchild=p;
	}
	return 1;
}
int InsertR_Bitree(Bitnode *parent,datatypebt x)
/*右插入函数1.先决条件:无2.函数作用:在二叉树中的parent所指结点和其右子树之间插入数据元素为x的结点,成功返回1*/
{
	Bitnode *p;
	if(parent==NULL)
	{
		printf("插入出错.
");/*此句可以根据情况删除*/
		return 0;
	}
	p=(Bitnode *)malloc(sizeof(Bitnode));
	p->data=x;
	p->lchild=NULL;
	p->rchild=NULL;
	if(parent->rchild==NULL)
		parent->rchild=p;
	else
	{
		p->rchild=parent->rchild;
		parent->rchild=p;
	}
	return 1;
}
int DeleteL_Bitree(Bitnode *parent)
/*左删除函数1.先决条件:parent为子树的根结点,拥有Postfree_Bitree()函数2.函数作用:在二叉树中删除parent的左子树,成功返回1*/
{
	Bitnode *p;
	if(parent==NULL||parent->lchild==NULL)
	{
		printf("删除出错.
");/*此句可以根据情况删除*/
		return NULL;
	}
	p=parent->lchild;
	parent->lchild=NULL;
	Postfree_Bitree(p);
	return 1;
}
int DeleteR_Bitree(Bitnode *parent)
/*右删除函数1.先决条件:parent为子树的根结点,拥有Postfree_Bitree()函数2.函数作用:在二叉树中删除parent的右子树,成功返回1*/
{
	Bitnode *p;
	if(parent==NULL||parent->rchild==NULL)
	{
		printf("删除出错.
");/*此句可以根据情况删除*/
		return NULL;
	}
	p=parent->rchild;
	parent->rchild=NULL;
	Postfree_Bitree(p);
	return 1;
}
Bitnode *Parent_Bitree(Bitree bt,Bitnode *x)
/*求双亲函数1.先决条件:初始化二叉树bt,bt是子树根或头结点;2.函数作用:求二叉树bt中结点x的双亲结点,若结点x是二叉树的根结点或二叉树bt中无结点x,则返回NULL*/
{
	Bitnode *p=NULL;
	if(bt)
	{
		if(bt->lchild==x||bt->rchild==x)
		{
			p=bt;
			return p;
		}
		p=Parent_Bitree(bt->lchild,x);
		if(p)
			return p;
		p=Parent_Bitree(bt->rchild,x);
		if(p)
			return p;
	}
	return NULL;
}
void Visit_Bitree(Bitnode *p)
/*访问函数1.先决条件:无2.函数作用:输出一个二叉树结点p的数据*/
{
	if(p)
		printf("%c ",p->data);
}
int Countleaf_Bitree(Bitree bt)
/*统计叶子数函数1.先决条件:初始化二叉树,bt是子树根或头结点2.函数作用:统计二叉树bt中叶子结点的个数,返回值为bt的叶子数*/
{
	if(bt==NULL)
		return 0;
	if(bt->lchild==NULL&&bt->rchild==NULL)
		return 1;
	return Countleaf_Bitree(bt->lchild)+Countleaf_Bitree(bt->rchild);
}
void Preorder_Bitree(Bitree bt)
/*先序遍历函数1.先决条件:初始化二叉树,bt是子树根或头结点;2.函数作用:用递归方法先序遍历二叉树bt*/
{
	if(bt==NULL)
		return;
	Visit_Bitree(bt);
	Preorder_Bitree(bt->lchild);
	Preorder_Bitree(bt->rchild);
}
void Inorder_Bitree(Bitree bt)
/*中序遍历函数1.先决条件:初始化二叉树,bt是子树根或头结点;2.函数作用:用递归方法中序遍历二叉树bt*/
{
	if(bt==NULL)
		return;
	Inorder_Bitree(bt->lchild);
	Visit_Bitree(bt);
	Inorder_Bitree(bt->rchild);
}
void Postorder_Bitree(Bitree bt)
/*后序遍历函数1.先决条件:初始化二叉树,bt是子树根或头结点;2.函数作用:用递归方法后序遍历二叉树bt*/
{
	if(bt==NULL)
		return ;
	Postorder_Bitree(bt->lchild);
	Postorder_Bitree(bt->rchild);
	Visit_Bitree(bt);
}
int NRPreorder_Bitree(Bitree bt)
/*非递归先序遍历函数1.先决条件:初始化二叉树,bt是子树根或头结点2.函数作用:非递归先序遍历二叉树bt,空树返回0,非空树返回1,栈溢出返回-1*/
{
	Bitnode *p,*s[MAXNODE];/*MAXNODE最少是二叉树的层数h*/
	int top=-1;
	if((p=bt)==NULL)
	{
		printf("此为空二叉树.
");/*此句可以根据情况删除*/
		return 0;
	}
	while(p!=NULL||top!=-1)
	{
		while(p!=NULL)
		{
			Visit_Bitree(p);
			top++;
			if(top>=MAXNODE)
			{
				printf("栈溢出.
");
				return -1;
			}
			s[top]=p;
			p=p->lchild;
		}
		
		p=s[top];
		top--;
		p=p->rchild;
	}
	return 1;
}
int NRInorder_Bitree(Bitree bt)
/*非递归中序遍历函数1.先决条件:初始化二叉树,bt是子树根或头结点2.函数作用:非递归中序遍历二叉树bt,空树返回0,非空树返回1,栈溢出返回-1*/
{
	Bitnode *p,*s[MAXNODE];/*MAXNODE最少是二叉树的层数h*/
	int top=-1;
	if((p=bt)==NULL)
	{
		printf("此为空二叉树.
");/*此句可以根据情况删除*/
		return 0;
	}
	while(p!=NULL||top!=-1)
	{
		while(p!=NULL)
		{
			top++;
			if(top>=MAXNODE)
			{
				printf("栈溢出.
");
				return -1;
			}
			s[top]=p;
			p=p->lchild;
		}
		p=s[top];
		Visit_Bitree(p);
		top--;
		p=p->rchild;
	}
	return 1;
}
int NRPostorder_Bitree(Bitree bt)
/*非递归后序遍历函数1.先决条件:初始化二叉树,bt是子树根或头结点2.函数作用:非递归后序遍历二叉树bt,p为当前结点指针,q为前驱结点指针,空树返回0,非空树返回1,栈溢出返回-1*/
{
	Bitnode *s[MAXNODE];/*MAXNODE最少是二叉树的层数h*/
	int top;
	Bitnode *p,*q;
	q=NULL;
	p=bt;
	if(!p)
		return 0;
	top=-1;
	while(p!=NULL||top!=-1)
	{
		while(p!=NULL)
		{
			top++;
			if(top>=MAXNODE)
			{
				printf("栈溢出.
");
				return -1;
			}
			s[top]=p;
			p=p->lchild;
		}
		if(top>-1)
		{
			p=s[top];
			if(p->rchild==NULL||p->rchild==q)
			{
				Visit_Bitree(p);
				q=p;
				top--;
				p=NULL;
			}
			else
				p=p->rchild;
		}
	}
	return 1;
}
int Levelorder_Bitree(Bitree bt)
/*层次遍历二叉树函数1.先决条件:bt是子树根结点2.函数作用:层次遍历二叉树bt,队满溢出返回-1,空树返回0,非空树返回1*/
{
	Bitnode *sq[BOTTOMNODE];/*MAXNODE最少是2^(h-1),其中h为层数*/
	int front=-1,rear=0,num=0;
	if(bt==NULL)
		return 0;
	if(num<MAXNODE)
	{
		sq[rear]=bt;
		num++;
	}
	else
	{
		printf("队满.
");/*可视情况删除此句*/
		return -1;
	}
	while(num)
	{
		front=(front+1)%MAXNODE;
		num--;
		Visit_Bitree(sq[front]);
		if(sq[front]->lchild)
			if(num==MAXNODE)
			{
				printf("队满.
");/*可视情况删除此句*/
				return -1;
			}
			else
			{
				rear=(rear+1)%MAXNODE;
				sq[rear]=sq[front]->lchild;
				num++;
			}
		if(sq[front]->rchild)
			if(num==MAXNODE)
			{
				printf("队满.
");/*可视情况删除此句*/
				return -1;
			}
			else
			{
				rear=(rear+1)%MAXNODE;
				sq[rear]=sq[front]->rchild;
				num++;
			}
	}
	return 1;
}
int Posttreedepth_Bitree(Bitree bt)
/*后序二叉树高度函数1.先决条件:bt为子树根结点2.函数作用:通过后序遍历求二叉树bt的高度,返回二叉树的高度*/
{
	int hl,hr,max;
	if(bt!=NULL)
	{
		hl=Posttreedepth_Bitree(bt->lchild);
		hr=Posttreedepth_Bitree(bt->rchild);
		max=hl>hr?hl:hr;
		return max+1;
	}
	else
		return 0;
}
void Pretreedepth_Bitree(Bitree bt,int h,int *depth)
/*前序二叉树高度函数1.先决条件:bt是子树根结点,h为bt结点所在层次,初值为1,depth为当前求得的最大层次,调用前初值为0;
2.函数作用:通过先序遍历求二叉树bt高度*/
{
	if(bt!=NULL)
	{
		if(h>*depth)
			*depth=h;
		Pretreedepth_Bitree(bt->lchild,h+1,depth);
		Pretreedepth_Bitree(bt->rchild,h+1,depth);
	}
}
void Pretreelevel_Bitree(Bitree bt,int h)
/*前序二叉树打印层号函数1.先决条件:bt是子树根结点,h为bt结点所在层次,初值为1;2.函数作用:通过先序遍历打印二叉树bt中结点和层号*/
{
	if(bt!=NULL)
	{
		printf("%d %c
",h,bt->data);
		Pretreelevel_Bitree(bt->lchild,h+1);
		Pretreelevel_Bitree(bt->rchild,h+1);
	}
}
void Pretreenode_Bitree(Bitree bt,int *num)
/*前序二叉树结点函数1.先决条件:bt是子树根结点,num为累计的结点数,调用前初值为0;2.函数作用:通过先序遍历求二叉树的结点数目num*/
{
	if(bt!=NULL)
	{
		*num=*num+1;
		Pretreenode_Bitree(bt->lchild,num);
		Pretreenode_Bitree(bt->rchild,num);
	}
}
int Print1_Bitree(Bitree bt)
/*按树状打印二叉树函数1.先决条件:bt是子树根结点,拥有Posttreedepth_Bitree()函数2.函数作用:按树状打印二叉树bt*/
{
	int i,j,k,n,flag=1,kongge,chuduigeshu=1;
	Bitnode *sq[FULLNODE],*temp;/*FULLNODE最少为满二叉树结点数+1*/
	int rear,front,num;
	if(bt==NULL)
		return 0;
	front=rear=FULLNODE-1;
	num=0;
	if(num==FULLNODE)
	{
		printf("队满.
");/*可视情况删除此句*/
		return -1;
	}
	else
	{
		rear=(rear+1)%FULLNODE;
		sq[rear]=bt;
		num++;
	}
	n=Posttreedepth_Bitree(bt);
	for(i=1,kongge=1;i<n;i++)
		kongge=kongge*2;
	for(i=1;i<=n;i++)
	{
		j=1;
		while(j<=chuduigeshu)
		{
			if(flag==1)
			{
				for(k=1;k<kongge;k++)
					printf(" ");/*因树结点的数据长度不同而不同*/
				front=(front+1)%FULLNODE;
				temp=sq[front];
				num--;
				if(temp)
				{
					printf("%c",temp->data);/*因二叉树数据类型不同而不同*/
					if(num==FULLNODE-1)
					{
						printf("队满.
");/*可视情况删除此句*/
						return -1;
					}
					else
					{
						rear=(rear+1)%FULLNODE;
						sq[rear]=temp->lchild;
						rear=(rear+1)%FULLNODE;
						sq[rear]=temp->rchild;
						num=num+2;
					}
				}
				else
				{
					printf(" ");/*因树结点的数据长度不同而不同*/
					if(num==FULLNODE-1)
					{
						printf("队满.
");/*可视情况删除此句*/
						return -1;
					}
					else
					{
						rear=(rear+1)%FULLNODE;
						sq[rear]=NULL;
						rear=(rear+1)%FULLNODE;
						sq[rear]=NULL;
						num=num+2;
					}
				}
				j++;
			}
			else
				for(k=1;k<=kongge;k++)
					printf(" ");/*因树结点的数据长度不同而不同*/
			flag=-flag;
		}
		printf("
");
		kongge=kongge/2;
		chuduigeshu=chuduigeshu*2;
		flag=1;
	}
	return 1;
}
void Print2_Bitree(Bitree bt,int nlayer)
/*按竖向树状打印二叉树函数1.先决条件:bt为子树根结点,nlayer为bt指向结点所在层次,初值为0;2.函数作用:按竖向树状打印二叉树bt*/
{
	if(bt==NULL)
		return ;
	Print2_Bitree(bt->rchild,nlayer+1);
	for(int i=0;i<nlayer;i++)
		printf(" ");/*因树结点的数据长度不同而不同*/
	printf("%c
",bt->data);/*因树结点的数据类型不同而不同*/
	Print2_Bitree(bt->lchild,nlayer+1);
}