数据结构_树形结构_二叉树



数据结构_树形结构_二叉树

根据实验报告,对二叉树的基本操作进行的整理:

（1）采用下列方法之一建立二叉树的二叉链表：

① 输入完全二叉树的先序序列，用#代表虚结点（空指针），如ABD###CE##F##，建立二叉树的二叉链表。

void CreatBiTree(BiTree &bt){

//① 输入完全二叉树的先序序列，用#代表虚结点（空指针），如ABD###CE##F##，建立二叉树的二叉链表。

char ch;

ch = getchar();

if(ch=='#')

bt = NULL;

else{

bt = (BiTree)malloc(sizeof(BTNode));

bt->data = ch;

CreatBiTree(bt->lchild);

CreatBiTree(bt->rchild);

}

}//CreatBiTree

② 已知二叉树的先序遍历序列和中序遍历序列，或者已知二叉树的中序遍历序列和后序遍历序列，建立二叉树的二叉链表。

void CreatBiTree(BiTree &bt,char PreOrder[],char InOrder[],int NodeNumber){

//利用先序遍历和中序遍历创建二叉链表

char PreOrderL[20],PreOrderR[20],InOrderL[20],InOrderR[20];//可以跟据结点数,自行定义数组长度

int i=0,j,light,right;

if(bt) bt = NULL; exit(0);

else {bt = (BiTree)malloc(sizeof(BTNode));

if(!bt) exit(0);

bt->data = PreOrder[0];

while(InOrder[i]!=bt->data)

i++;

for(j=0;j<i;j++){

PreOrderL[j] = PreOrder[j+1];

InOrderL[j] = InOrder[j];

}

for(j = i+1;j<NodeNumber;j++){

PreOrderR[j-i-1] = PreOrder[j];

InOrderR[j-i-1] = InOrder[j];

}

light = i;     right = j;

if(light < 1)

bt->lchild = NULL;

else 

CreatBiTree(bt,PreOrderL,InOrderL,light);

if(right < 1)

bt->rchild = NULL;

else

CreatBiTree(bt,PreOrderR,InOrderR,right);

}

}③ 将一棵二叉树的所有结点存储在一维数组中，虚结点用#表示，利用二叉树的性质5，建立二叉树的二叉链表。例如用数组a存储的二叉树的结点如下（0单元不用）：

void CreatBiTree(BiTree &bt,char Data[],int n){

 

CQueue Q;

int Qn[MAX],f,r,i;

BiTree p;

if(n<1){

bt = NULL;

return;

}

bt = (BiTree)malloc(sizeof(BTNode));

bt ->data = Data[1];

InitQueue(Q); EnQueue(Q,bt);

f = r = 0;

Qn[r++]=1;

while(!QueueEmpty(Q)){

DeQueue(Q,p); i=Qn[f++];

if(2*i > n || Data[2*i] == '#')

p->lchild = NULL;

else{

p->lchild = (BiTree)malloc(sizeof(BTNode));

p->lchild->data = Data[2*i];

EnQueue(Q,p->lchild);

Qn[r++] = 2*i;

}

if(2*i+1 > n || Data[2*i+1] == '#')

p->rchild = NULL;

else{

p->rchild = (BiTree)malloc(sizeof(BTNode));

p->rchild->data = Data[2*i+1];

EnQueue(Q,p->rchild);

Qn[r++] = 2*i+1;

}

}

 

}

（2）写出对用二叉链表存储的二叉树进行先序、中序和后序遍历的递归和非递归算法。

//------------------二叉树的递归遍历-----------------------------

void PreOrderTraverse(BiTree bt){

//二叉树先序遍历的递归算法

if(bt){

printf("%c",bt->data);

PreOrderTraverse(bt->lchild);

PreOrderTraverse(bt->rchild);

}

}//PreOrderTraverse

 

void InOrderTraverse(BiTree bt){

//二叉树中序遍历的递归算法

if(bt){

InOrderTraverse(bt->lchild);

printf("%c",bt->data);

InOrderTraverse(bt->rchild);

}

}//InOrderTraverse

 

void PostOrderTraverse(BiTree bt){

//二叉树后序遍历的递归算法

if(bt){

PostOrderTraverse(bt->lchild);

PostOrderTraverse(bt->rchild);

printf("%c",bt->data);

}

}//PostOrderTraverse

 

//------------------非递归遍历的实现---------------------------

void PreOrderTraverse(BiTree bt){

//二叉树的非递归遍历

BiTree p;

SqStack s;

if(bt){

InitStack(s);

Push(s,bt);

while(!StackEmpty(s)){

while(GetTop(s,p) && p){

printf("%3c",p->data);

Push(s,p->lchild);

}

Pop(s,p);

if(!StackEmpty(s)){

Pop(s,p);

Push(s,p->rchild);

}

}

}

printf("\n");

}//PreOrderTraverse

 

void InOrderTraverse(BiTree bt){

//非递归函数的中序遍历

SqStack s;

BiTree p;

if(bt){

InitStack(s);

Push(s,bt);

while(!StackEmpty(s)){

while(GetTop(s,p) && p)

Push(s,p->lchild);

Pop(s,p);

if(!StackEmpty(s)){

Pop(s,p);

printf("%3c",p->data);

Push(s,p->rchild);

}

}

}

printf("\n");

}//InOrderTraverse

 

void PostOrderTraverse(BiTree bt){

//非递归函数的后序遍历

SqStack s;

BiTree p,q;

if(bt){

InitStack(s);

Push(s,bt);

while(!StackEmpty(s)){

while(GetTop(s,p) && p)

Push(s,p->lchild);

Pop(s,p);

if(!StackEmpty(s)){

GetTop(s,p);

if(p->rchild)

Push(s,p->rchild);

else{

Pop(s,p);

printf("%3c",p->data);

while(!StackEmpty(s) && GetTop(s,q) && q->rchild == p){

Pop(s,p);

printf("%3c",p->data);

}

if(!StackEmpty(s)){

GetTop(s,p);

Push(s,p->rchild);

}

}

}

}

}

printf("\n");

}//PostOrderTraverse

（3）写出对用二叉链表存储的二叉树进行层次遍历算法。

void LevelOrderTraverse(BiTree bt)

{

Queue Q;

int count=0;

BiTree p;

if (bt)

{

InitQueue(Q); EnQueue(Q, bt);

while (!QueueEmpty(Q))

{

DeQueue(Q, p);

printf("%3c", p->data);

count++;

if (p->lchild)EnQueue(Q, p->lchild);

if (p->rchild)EnQueue(Q, p->rchild);

 

}

}

printf("结点数为：%d",count);

}