二叉树的基本操作

#include<iostream>

using namespace std;

#include<malloc.h>

#define MaxSize 100

typedef charElemType;

typedef struct node

{

ElemTypedata;                /*数据元素*/

struct node*lchild;                /*指向左孩子*/

struct node*rchild;                /*指向右孩子*/

} BTNode;

typedefstruct /*类型定义*/

{

BTNode  *data[MaxSize];

inttop;

}Sqstack;          

typedef struct

{

BTNode*node;  

int flag;      //后序

}Elem;        

typedef struct

{

   Elem data[MaxSize];

   int top;

}Sqstack2;                                                                        

voidInitstack(Sqstack *&S)//初始化

{

S=(Sqstack*)malloc(sizeof(Sqstack));

S->top=-1;                        

}

voidInitstack2(Sqstack2 *&S)//初始化 

{

S=(Sqstack2*)malloc(sizeof(Sqstack2));

S->top=-1;                        

}                                

intEmptyStack(Sqstack *S)/* 判断是否为空*/

{

return(S->top==-1);

}                

intEmptyStack2(Sqstack2 *S)/* 判断是否为空*/ 

{

return(S->top==-1);

}                                                                                

intpush(Sqstack *&S,BTNode *e)//入栈数据元素

{

if(S->top==MaxSize-1)

return0;

S->top++;

S->data[S->top]=e;

return1;

}

 

intPop(Sqstack *&S,BTNode *&e)//出栈：将栈顶元素删除

{

if(S->top==-1)

return0;

e=S->data[S->top];

S->top--;

return1;

}

intPush2(Sqstack2 *&S,Elem e)//入栈2

{

if(S->top==MaxSize-1)

return0;

S->top++;

S->data[S->top]=e;

return1;

}

 

intPop2(Sqstack2 *&S,Elem &e)//出栈：将栈顶元素删除2

{

if(S->top==-1)

return0;

e=S->data[S->top];

S->top--;

return1;

}

 

voidCreateBTNode(BTNode *&b,char*str)                /*由str串创建二叉链*/

{

BTNode*St[MaxSize],*p=NULL;

inttop=-1,k,j=0; 

charch;

b=NULL;                                /*建立的二叉树初始时为空*/

ch=str[j];

while(ch!='\0')        /*str未扫描完时循环*/

{

                    switch(ch)

{

case '(':top++;St[top]=p;k=1;break;                /*为左结点*/

case')':top--;break;

case ',':k=2; break;                             /*为右结点*/

default:p=(BTNode*)malloc(sizeof(BTNode));

p->data=ch;p->lchild=p->rchild=NULL;

                if (b==NULL)                    /*p指向二叉树的根结点*/

b=p;

else                                                         /*已建立二叉树根结点*/

{        

switch(k)

{

case1:St[top]->lchild=p;break;

case2:St[top]->rchild=p;break;

}

}

}

j++;

ch=str[j];

}

}

voidDispBTNode(BTNode *b)        /*以括号表示法输出二叉树*/

{

if(b!=NULL)

{

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

if(b->lchild!=NULL || b->rchild!=NULL)

{

printf("(");

DispBTNode(b->lchild);

if(b->rchild!=NULL) printf(",");

DispBTNode(b->rchild);

printf(")");

}

}

}

 

voidPreOrder2(BTNode *t)//先序非递归

{

Sqstack*S;

         Initstack(S);

BTNode*p=t;

while(p||!EmptyStack(S))

{

if(p)

{

cout<<p->data;

push(S,p);

p=p->lchild;

}

else

{

Pop(S,p);

p=p->rchild;

}

}

 

}

voidInOrder2(BTNode *b)//中序非递归

{

Sqstack*S;

Initstack(S);

BTNode*p=b;

while(p||!EmptyStack(S))

{

if(p)

{

push(S,p);

p=p->lchild;

}

else

{

Pop(S,p);

cout<<p->data;

p=p->rchild;

}

}

}

voidPostOrder2(BTNode *t)//后序非递归

{

Sqstack2*S;

Elemsq;

BTNode*p=t;

Initstack2(S);

while(p||!EmptyStack2(S))

{

if(p)

 

{ sq.flag=1;        

sq.node=p;        

   Push2(S,sq);

   p=p->lchild;

 

}

else

 

{        Pop2(S,sq);        

    p=sq.node;

   

if(sq.flag==1)

{

sq.flag=2;

Push2(S,sq);

p=p->rchild;

 

}

else

{

cout<<p->data;        

p=NULL;

 

}

}

}

}

voidTravLevel(BTNode *b)//层次遍历

{

BTNode*queue[MaxSize]={0};

intfront=-1,rear=0;

if(b!=NULL)

{

queue[rear]=b;

while(front!=rear)

{

front++;

cout<<queue[front]->data;

if(queue[front]->lchild!=NULL)

queue[++rear]=queue[front]->lchild;

if(queue[front]->rchild!=NULL)

queue[++rear]=queue[front]->rchild;

}

}

}

voidPreOrder1(BTNode *b)  //先序遍历递归算法

{

if(b!=NULL)

{

cout<<b->data;

PreOrder1(b->lchild);

PreOrder1(b->rchild);

}

 

}

 

voidInOrder1(BTNode *b) //中序遍历递归算法

{

if(b!=NULL)

{

InOrder1(b->lchild);

cout<<b->data;

InOrder1(b->rchild);

}

 

}

 

voidPostOrder1(BTNode *b)  //后序遍历递归算法

{

if(b!=NULL)

{

PostOrder1(b->lchild);

PostOrder1(b->rchild);

cout<<b->data;

}

}

 

voidDispleaf(BTNode *b) //根据定义输出所有叶子

{

if(b!=NULL)

{

if(b->lchild==NULL&&b->rchild==NULL)

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

else

{

Displeaf(b->lchild);

Displeaf(b->rchild);

}

}

}

intleafno(BTNode *b) //求叶子结点个数

{ int lno,rno;

if(b==NULL) return0;

if(b->lchild==NULL&&b->rchild==NULL)

return 1;

else

{

lno=leafno(b->lchild);

rno=leafno(b->rchild);

return lno+rno;

}

}

 

 

intcount1(BTNode *b)//求度为1结点的个数

{int lno,rno;

if(b==NULL||b->lchild==NULL&&b->rchild==NULL)return 0;

lno=count1(b->lchild);

rno=count1(b->rchild);

if(b->lchild!=NULL&&b->rchild!=NULL)

return lno+rno;

else

return lno+rno+1;

}

 

int n2=0;

intcountNode2(BTNode *b) //统计度为2的结点总数

{

if(b!=NULL)

{

countNode2(b->lchild);

if(b->lchild!=NULL&&b->rchild!=NULL)

n2++;

 countNode2(b->rchild);

}

return n2;

}

 

int n=0;

intcountNode(BTNode *b) //根据遍历统计结点总数

{

if(b!=NULL)

{

countNode(b->lchild);

n++;

countNode(b->rchild);

}

return n;

}

 

intNodecount(BTNode *b) //根据定义统计结点总数

{

int lno,rno;

if(b==NULL)return0;

lno=Nodecount(b->lchild);

rno=Nodecount(b->rchild);

return lno+rno+1;

}

 

int d=0;

intBTNodeDepth(BTNode *b)//求二叉树b的深度

{

int lno,rno;

if(b==NULL)return0;

if(b)

{lno=BTNodeDepth(b->lchild);

rno=BTNodeDepth(b->rchild);

d=lno>=rno?lno+1:rno+1;

}

 

return d;

}

void main() 

{

BTNode*b;

char*str="A(B(D(,G),E(H)),C(F,))";

CreateBTNode(b,str);

    DispBTNode(b);

cout<<'\n';

cout<<"1-1：先序遍历递归算法:";

PreOrder1(b);

cout<<'\n';

cout<<"1-2：先序遍历非递归算法:";

PreOrder2(b);

cout<<'\n';

cout<<"2-1：中序遍历递归算法:";

InOrder1(b);

cout<<'\n';

cout<<"2-2：中序遍历非递归算法:";

InOrder2(b);

cout<<'\n';

cout<<"3-1：后序遍历递归算法：";

PostOrder1(b);

cout<<'\n';

    cout<<"3-2：后序遍历非递归算法：";

PostOrder2(b);

cout<<'\n';

cout<<"4：层次遍历算法:";

TravLevel(b);

cout<<'\n';

    cout<<"5：输出所有叶子:";

    Displeaf(b) ;

    cout<<'\n';

cout<<"6：求二叉树的深度:";

    cout<<BTNodeDepth(b);

    cout<<'\n';

    cout<<"7：叶子结点个数:";

    cout<<leafno(b) ;

    cout<<'\n';

cout<<"8：度为1结点的个数:";

    cout<<count1(b) ;

    cout<<'\n';

    cout<<"9：度为2的结点总数:";

    cout<<countNode2(b) ;

    cout<<'\n';

cout<<"10：根据遍历求结点总数:";

    cout<<countNode(b) ;

    cout<<'\n';

    cout<<"11：根据定义求结点总数:";

    cout<<Nodecount(b) ;

    cout<<'\n';

}