二叉树结构建立及其基本操作验证 程序设计

二叉链表的类型定义及二叉树建立、插入、删除、查找、遍历等各个操作的算法思想描述以及代码实现。

代码

#include<iostream>
#include<malloc.h>
 #include<stdio.h>
 #include<stdlib.h>
using namespace std;

typedef int Status;
typedef char TElemType;      //二叉树数据类型为字符型，char可修改
TElemType N=' ';

#define OK    1
#define TRUE  1
#define ERROR 0
#define FALSE 0
#define OVERLOW -2

/**********************二叉树的链表储存********************************/
typedef struct BiTNode   //二叉树结点
{
	TElemType data;
	BiTNode *lchild,*rchild;
}*BiTree;
Status InitBT(BiTree *T)  //创建空树
{
	*T=NULL;
	return OK;
}
Status DestoryBT(BiTree *T)  //销毁二叉树
{
	if(*T)
	{
		if((*T)->lchild) DestoryBT(&(*T)->lchild);  //递归方法销毁左、右子树
		if((*T)->rchild) DestoryBT(&(*T)->rchild);
	    free(*T);
		*T=NULL;
	}
	return OK;
}
void CreateBT(BiTree *T)  //先序递归创建二叉树
{
	TElemType ch;
	ch=getchar();
	if(ch==N)
		*T=NULL;
	else
	{
		*T=(BiTNode*)malloc(sizeof(BiTNode));
		if(!T) exit(OVERLOW);
		(*T)->data=ch;
		CreateBT(&(*T)->lchild);
		CreateBT(&(*T)->rchild);
	}
}
int BTDepth(BiTree T)  //计算树深
{
	int i,j;
	if(!T) return 0;
	if(T->lchild)  i=BTDepth(T->lchild);
	else i=0;
	if(T->rchild)  j=BTDepth(T->rchild);
	else j=0;
	return i>j?i+1:j+1;
}
TElemType Root(BiTree T)  //返回树根元素
{
	if(!T) return N;
	else return T->data;
}
void TraverseBT1(BiTree T)  //先序递归遍历
{
	if(T)
	{
	    cout<<T->data;
	    TraverseBT1(T->lchild);
	    TraverseBT1(T->rchild);
	}
	else cout<<N;
}
void TraverseBT2(BiTree T)  //中序递归遍历
{
	if(T)
	{
		TraverseBT2(T->lchild);
	    cout<<T->data;
	    TraverseBT2(T->rchild);
	}
	else cout<<N;
}
void TraverseBT3(BiTree T)  //后序递归遍历
{
	if(T)
	{
		TraverseBT3(T->lchild);
		TraverseBT3(T->rchild);
	    cout<<T->data;
	}
	else 
		cout<<N;
}
/*************************************************************/

/*****************队列的链式储存结构**************************/
typedef BiTree QElemType;
struct QNode   //队列的结点
{
	QElemType data;
	QNode *next;
};
class QLink
{
public:
	QNode *front,*rear;  //队头、队尾指针
	int length;
	QLink()              //构造空队列
	{
		front=rear=(QNode*)malloc(sizeof(QNode));
		if(!front) exit(OVERLOW);
		front->next=NULL;
		length=0;
	}
	~QLink()        //销毁队列
	{
		while(front)
		{
		    rear=front->next;
			free(front);
			front=rear;
		}
	}
	Status ClearQLink() //队列清空
	{
		QNode *p,*q;
		rear=front;
		q=front->next;
		while(q)
		{
			p=q->next;
			free(q);
			q=p;
		}
		length=0;
		return OK;
	}
	Status QLinkEmpty()  //判断空队列
	{
		if(rear==front)
			return TRUE;
		else return FALSE;
	}
	Status GetHead(QElemType *e) //获得队头元素
	{
		if(front==rear) return ERROR;
		*e=front->next->data;
		return OK;
	}
	Status EnQLink(QElemType e) //队尾插入元素
	{
	    QNode *p=(QNode*)malloc(sizeof(QNode));
		p->data=e;
		p->next=NULL;
		rear->next=p;
		rear=p;
		return OK;
	}
	Status DeQLink(QElemType *e)   //删除队头元素
	{
		if(front==rear) return ERROR;
		QNode *p=front->next;
		*e=p->data;
		front->next=p->next;
		if(p==rear)
			rear=front;
		free(p);
		return OK;
	}
};
/**************************************************************/

/**********************栈的顺序存储结构************************/
typedef BiTree SElemType;
#define Stack_Init_Size 10   //顺序栈空间初始分配量
#define StackIncrement  2    //储存空间分配增量
class Sqstack
{
public:
	SElemType *base,*top;
	int stacksize;
	int length;
	Sqstack()  //构造空栈
	{
		base=(SElemType*)malloc(Stack_Init_Size*sizeof(SElemType));
		top=base;
		stacksize=Stack_Init_Size;
		length=0;
	}
	~Sqstack()  //销毁栈
	{
	    free(base);
		base=NULL;
		top=NULL;
		stacksize=0;
	}
	Status ClearStack()   //置为空栈
	{
		top=base;
		length=0;
		return OK;
	}
	Status StackEmpty()   //判断空栈
	{
	    if(top==base)
			return TRUE;
		else
			return FALSE;
	}
	Status GetTop(SElemType *e)  //获得栈顶元素
	{
		if(top>base)
		{
	    e=top-1;
		return OK;
		}
		else return ERROR;
	}
	Status Push(SElemType e)   // 插入栈顶
	{
		if(top-base>=stacksize)
		{
			base=(SElemType*)realloc(base,(stacksize+StackIncrement)*sizeof(SElemType));
		    if(!base)
		    	exit(OVERLOW);  //储存空间分配失败
		    top=base+stacksize;
			stacksize+=StackIncrement;
		}
		*top=e;
		top++;
		length++;
		return OK;
	}
     Status  Pop(SElemType *e)  //删除栈顶元素
    {
	    if(top==base) return ERROR;
	    *e=*--top;
	    length--;
	    return OK;
    }
};

/**************************************************************/


TElemType Parent(BiTree T,TElemType e)   //返回非根结点e的parent,用队列实现
{
	QLink q;
	BiTree a;
	if(T)
	{
		q.EnQLink(T);
		while(!q.QLinkEmpty()) 
		{
			q.DeQLink(&a);
			if(a->lchild&&a->lchild->data==e||a->rchild&&a->rchild->data==e)
				return a->data;
			else
			{
				if(a->lchild) q.EnQLink(a->lchild);
				if(a->rchild) q.EnQLink(a->rchild);
			}
		}
	}
	return N;
}
BiTree Point(BiTree T,TElemType e)    //返回元素为e的指针
{
    QLink q;
	QElemType a;
	if(T)
	{
		q.EnQLink(T);
		while(!q.QLinkEmpty())
		{  
			q.DeQLink(&a);
			if(a->data==e)
				return a;
			if(a->lchild)
				q.EnQLink(a->lchild);
			if(a->rchild)
				q.EnQLink(a->rchild);
		}
	}
	return NULL;
}
TElemType Child(BiTree T,TElemType e,int lr)   //返回e的孩子,1左0右
{
	BiTree a;
	if(T)
	{
	    a=Point(T,e);
		if(lr)
		{
			if(a->lchild) return a->lchild->data;
		}
		else
		{
			if(a->rchild) return a->rchild->data;
		}
	}
	return N;
}

TElemType Brother(BiTree T,TElemType e,int lr)     //返回e的兄弟,1左0右
{
	TElemType p;
	BiTree a;
	if(T)
	{
		p=Parent(T,e);
	    a=Point(T,p);
		if(lr)
		{
			if(a->lchild&&a->lchild->data!=e) return a->lchild->data;
		}
		else
		{
			if(a->rchild&&a->rchild->data!=e) return a->rchild->data;
		}

	}
	return N;
}

Status IncertChild(BiTree p,int lr,BiTree c)    //插入子树，1左0右
{
    if(p)
	{
	    if(lr)
			p->lchild=c;
		else
			p->rchild=c;
		return OK;
	}
	return ERROR;
}

Status DeleteChild(BiTree p,int lr)   //删除子树，1左0右
{
    if(p)
	{
	    if(lr)
			DestoryBT(&(p->lchild));
		else
			DestoryBT(&(p->rchild));
		return OK;
	}
	return ERROR;
}

Status TraverseBT4(BiTree T)      //中序非递归遍历
{
	Sqstack S;
	BiTree t;
	while(T||!S.StackEmpty())
	{
		if(T)
		{
			S.Push(T);
			T=T->lchild;
		}
		else
		{
			cout<<N;
			S.Pop(&t);
			cout<<t->data;
			T=t->rchild;
		}
	}
    cout<<endl;
	return OK;
}

void LevelTraverseBT(BiTree T)   //层序遍历，利用队列
{
	QLink q;
	QElemType a;
	if(T)
	{
		q.EnQLink(T);
		while(!q.QLinkEmpty())
		{
			q.DeQLink(&a);
			cout<<a->data;
			if(a->lchild) q.EnQLink(a->lchild);
			if(a->rchild) q.EnQLink(a->rchild);
		}
		cout<<endl;
	}
}

int main()
{
	int lr;
    BiTree T,tt,c;
	TElemType ch,t;
	cout<<"请按先序方式输入一个二叉树T（用空格表示空子树）：";
	CreateBT(&T);
	cout<<"//建立二叉树...\n树空否? ";
	if(T) cout<<"否"; else cout<<"是";
	cout<<"  树的深度："<<BTDepth(T)<<"\n二叉树的根为："<<Root(T)<<endl;
	cout<<"\n先序递归遍历二叉树：\n";
	TraverseBT1(T);
	cout<<"\n中序递归遍历二叉树：\n";
	TraverseBT2(T);
	cout<<"\n中序非递归遍历二叉树：\n";
	TraverseBT4(T);
	cout<<"后序递归遍历二叉树：\n";
	TraverseBT3(T);
	cout<<"\n层序遍历二叉树："<<endl;
	LevelTraverseBT(T);
	cout<<"请输入一个结点值："; 
	cin>>ch;
	c=Point(T,ch);
	if(c) 
	{
		cout<<"找到了该结点\n欲改变该结点值，请输入新值：";
		cin>>ch;
		c->data=ch;
		
		cout<<"\n层序遍历二叉树：\n";
	    LevelTraverseBT(T);
		t=Parent(T,ch);
		if(t!=N)
			cout<<ch<<"的双亲是："<<t<<'\n';
		else 
			cout<<ch<<"没有双亲\n";
		t=Child(T,ch,1);
		if(t!=N)
			cout<<ch<<"的左孩子是："<<t<<'\n';
		else 
			cout<<ch<<"没有左孩子\n";
		t=Child(T,ch,0);
		if(t!=N)
			cout<<ch<<"的右孩子是："<<t<<'\n';
		else 
			cout<<ch<<"没有右孩子\n";
		t=Brother(T,ch,1);
		if(t!=N)
			cout<<ch<<"的左兄弟是："<<t<<'\n';
		else 
			cout<<ch<<"没有左兄弟\n";
		t=Brother(T,ch,0);
		if(t!=N)
			cout<<ch<<"的右兄弟是："<<t<<'\n';
		else 
			cout<<ch<<"没有右兄弟\n";
	}
	else cout<<"不存在该结点...\n";

	cout<<"输入一个待插入的二叉树tt:"<<endl;
	fflush(stdin);
	CreateBT(&tt);
	cout<<"输入插入T的位置：结点 (1左0右)";
	cin>>ch>>lr;
	cout<<"\n先序递归遍历二叉树tt:\n";
	TraverseBT1(tt);
	c=Point(T,ch);
	IncertChild(c,lr,tt);
	cout<<"\n树tt插到树T中...\n先序递归遍历二叉树T:\n";
	TraverseBT1(T);
	cout<<"\n删除子树，请输入待删除子树的双亲结点：结点 (1左0右)";
	cin>>ch>>lr;
	c=Point(T,ch);
	DeleteChild(c,lr);
	cout<<"先序递归遍历二叉树T:\n";
	TraverseBT1(T);
	cout<<endl;
}

测试结果