二叉树的几个相关算法

#include "stdafx.h"
#include<string>
#include<iostream>
#define ERROR  0
#define OK  1
#define queuesize 20

using namespace std;

typedef struct BiTNode{
int data;
struct BiTNode *lchild,*rchild;
}BiTNode,*BiTree;

typedef struct Queue{
int front ,rear ;
BiTree data[queuesize];
int count;
}Queue;

/*======================================*\
|建立二叉树
|@date 2012/11/27
\*======================================*/
//先序建立二叉树
int create_BiTree(BiTree &T)
{
int ch;
cout<<"请输入一个根结点的值（如果为空，则输入0）\n";
cin>>ch;
if (ch==0) T= NULL;
else
{
T=new BiTNode;
if (T== NULL)  return ERROR;
T->data = ch;
create_BiTree(T->lchild);   // 构造左子树
create_BiTree(T->rchild);   // 构造右子树
}
return OK;
}

/*=========================================*\
|三种遍历
|@author LiMing
|@date   2012/11/27
\*=========================================*/
int pre_order_traverse(BiTree T) //先序遍历
{
if(T!=NULL)
{
cout<<T->data<<" ";
pre_order_traverse(T->lchild);
pre_order_traverse(T->rchild);
}
return OK;
}
int in_order_traverse(BiTree T)//中序遍历
{
if(T!=NULL)
{
in_order_traverse(T->lchild);
cout<<T->data<<" ";
in_order_traverse(T->rchild);
}
return OK;
}
int past_order_traverse(BiTree T)//后序遍历
{
if(T!=NULL)
{
past_order_traverse(T->lchild);
past_order_traverse(T->rchild);
cout<<T->data<<"";
}
return OK;
}

/*===================================*\
|非递归遍历
\*===================================*/
int pre_order_traverse2(BiTree T)
{
BiTree p,s[20];
int top=0;
p=T;
while((p!=NULL)||(top>0))
{
while(p!=NULL)
{
cout<<p->data<<" ";
s[++top]=p;
p=p->lchild;
}
p=s[top--];
p=p->rchild;
}
return OK;
}

int pre_order_traverse3(BiTree T)
{
BiTree p,stack[20];
p=T;
int top=-1;
for(;;)
{
for(;p;p=p->lchild)
{
cout<<p->data<<"";
stack[++top]=p;
}
if(top==-1)break;
p=stack[top--];
p=p->rchild;
}
return OK;
}

int in_order_traverse2(BiTree T)
{
BiTree p, stack[20];
p=T;
int top=-1;
for(;;)
{
for(;p;p=p->lchild)
stack[++top]=p;
if(top==-1)break;
p=stack[top--];
cout<<p->data<<" ";
p=p->rchild;
}
return OK;
}

//非递归后序遍历
int PastOrderTraverse2(BiTree T)
{
//此处省略一万字啊啊啊，一般不用
return 0;
}

/*======================================*\
|层次遍历法1
|@author LiMing
|@date 2012/11/28
\*======================================*/
int level_order_traverse1(BiTree T)
{    Queue *q;
BiTree p;
int flag=0;				 //定义flag为层号
q=new Queue;				 //申请循环队列空间
q->rear=q->front=q->count=0;		 //将循环队列初始化为空
q->data[q->rear]=T;
q->count++;
q->rear=(q->rear+1)%queuesize;		 //将根结点入队
while (q->count)				 //若队列不为空，做以下操作
if(q->data[q->front]){			 //当队首元素不为空指针，做以下操作
p=q->data[q->front];                //取队首元素*p
cout<<p->data<<endl;                //打印*p结点的数据域信息
++flag;
q->front=(q->front+1)%queuesize;
q->count--;                         //队首元素出队
if (q->count==queuesize)            //若队列为队满，则打印队满信息，退出程序的执行
cout<<"the queue full!\n";
else{                               //若队列不满，将*p结点的左孩子指针入队
q->count++;q->data[q->rear]=p->lchild;
q->rear=(q->rear+1)%queuesize;
}                                   //enf of if
if (q->count==queuesize)            //若队列为队满，则打印队满信息，退出程序的执行
cout<<"the queue full!\n";
else{                               //若队列不满，将*p结点的右孩子指针入队
q->count++;q->data[q->rear]=p->rchild;
q->rear=(q->rear+1)%queuesize;
}                                   //end of if
}                                       //end of if
else{                                   //当队首元素为空指针，将空指针出队
q->front=(q->front+1)%queuesize;
q->count--;
}
cout<<endl;
return OK;
}      //end of LevelOrder
/*======================================*\
|层次遍历法2
|@author LiMing
|@date 2012/11/29
\*======================================*/
int level_order_traverse2(BiTree T)
{
Queue *temp;
BiTree p;
temp=new Queue;
p=T;
if(!temp) return 0;
else
{
temp->count=0;
temp->front=-1;
temp->rear =-1;
}
temp->data[++temp->rear]=p;
temp->count++;
for(;temp->count;)
{
cout<<temp->data[++temp->front]->data<<" ";
temp->count--;
if(temp->data[temp->front]->lchild)
{
temp->data[++temp->rear]=temp->data[temp->front]->lchild;
temp->count++;
}
if(temp->data[temp->front]->rchild)
{
temp->data[++temp->rear]=temp->data[temp->front]->rchild;
temp->count++;
}
}
return 1;
}

/*===========================================*\
|与二叉树的性质有关的几种算法
|@author LiMinng
|@date 2012/11/28
\*===========================================*/

/**
*递归是不好实现的
*采用辅助栈的形式
*利用先序遍历的思想
*/

int get_all_node(BiTree T)
{
BiTree p,s[20];
int num_node=0;
int top=0;
p=T;
while((p!=NULL)||(top>0))
{
while(p!=NULL)
{
num_node++;
s[++top]=p;
p=p->lchild;
}
p=s[top--];
p=p->rchild;
}
return num_node;
}
/**
*循环体部分化为for()循环后
for(;;)
{
for(;p;p=p->lchild)
{
num_node++;
s[++top]=p;
}
if(top==0) break;
p=s[top--];
p=p->rchild;
}
*/

/**
*利用递归算法得到度为0的结点的个数
*不容易理解 效率也不高
*/

int get_node0_1(BiTree T)//
{
int num1,num2;
if(T==NULL)
return 0;
else
{
if((T->lchild==NULL)&&(T->rchild==NULL))
return 1;
else
{
num1=get_node0_1(T->lchild);
num2=get_node0_1(T->rchild);
return (num1+num2);
}
}
}
/**
*利用非递归算法得到度为0的结点的个数
*容易理解 效率高
*/

int get_node0_2(BiTree T)
{
int num=0;
BiTree p=T,s[20];
int top=0;
while((p!=NULL)||(top>0))
{
while(p!=NULL)
{
s[++top]=p;
p=p->lchild;
}
p=s[--top];
if(p->rchild==NULL)
{
++num;
}
else
p=p->rchild;
}
return num;
}

int get_node1(BiTree T) //利用总的关系求出度为1的结点的个数
{
int num=get_all_node(T)-2*get_node0_1(T)+1;
return num;
}
int get_node1_1(BiTree T)   //非递归算法，同时利用关系求度为1的结点。
{
int num=get_all_node(T)-2*get_node0_2(T)+1;
return num;
}
int get_node2(BiTree T) //利用度为2的结点个数与度为0的结点个数的关系得到
{
int num=get_node0_1(T)-1;
return num;
}
int get_node2_1(BiTree T)   //非递归算法，同时利用关系求度为2的结点。
{
int num=get_node0_2(T)-1;
return num;
}
int get_node(BiTree T)
{
int get;
cout<<"请输入你要查找的结点的度\n"<<endl;
cout<<"1.查询度为0的所有结点的个数\n"<<endl;
cout<<"2.查询度为1的所有结点的个数\n"<<endl;
cout<<"3.查询度为2的所有结点的个数\n"<<endl;
cin>>get;
switch(get){
case 1:
cout<<"度为0的所有结点的个数是%d\n"<<get_node0_1(T)<<endl;
break;
case 2:
cout<<"度为1的所有结点的个数是%d\n"<<get_node1(T)<<endl;
break;
case 3:
cout<<"度为2的所有结点的个数是%d\n"<<get_node2(T)<<endl;
break;
}
return OK;
}
int get_node_1(BiTree T)        //利用非递归算法的实现
{
int get;
cout<<"下面是用非递归算法来查询\n"<<endl;
cout<<"请输入你要查找的结点的度\n"<<endl;
cout<<"1.查询度为0的所有结点的个数\n"<<endl;
cout<<"2.查询度为1的所有结点的个数\n"<<endl;
cout<<"3.查询度为2的所有结点的个数\n"<<endl;
cin>>get;
switch(get){
case 1:
cout<<"度为0的所有结点的个数是%d\n"<<get_node0_2(T)<<endl;
break;
case 2:
cout<<"度为1的所有结点的个数是%d\n"<<get_node1_1(T)<<endl;
break;
case 3:
cout<<"度为2的所有结点的个数是%d\n"<<get_node2_1(T)<<endl;
break;
}
return OK;
}

/**
*求树的深度
*/
int height(BiTree T)
{
BiTree p=T;
int a,b;
if(p==NULL)
return 0;
else{
if((p->lchild==NULL)&&(p->rchild==NULL))
return 1;
else{
a=height(p->rchild);
b=height(p->lchild);
if(a>b)
return (a+1);
else
return (b+1);
}
}
}

/**
*采用递归算法来实现判断是否为完全二叉树
*/
int judge(BiTree T)
{
if(T ==NULL)
return   0;
if(T->lchild == NULL && T->rchild== NULL)
return   1;
if(T->lchild  == NULL  && T->rchild != NULL||T->lchild!=NULL &&T->rchild==NULL)
return   0;
return   judge(T->lchild) & judge(T->rchild);

}

int exchange(BiTree T)
{
BiTree p=T;
int exch;
if(p==NULL)
return OK;
else
{
if(p->lchild!=NULL && p->rchild!=NULL)
{
exch=p->lchild->data;
p->lchild->data=p->rchild->data;
p->rchild->data=exch;
exchange(p->lchild);
exchange(p->rchild);
}
else
{
if(p->lchild==NULL)
exchange(p->rchild);
else
exchange(p->lchild);
}
return OK;
}
}

void main()
{
BiTree T=new BiTNode;         //定义一个指向BiTNode结点的指针
int choice;
do{
cout<<"\n";
cout<<"请选择操作：\n";
cout<<"1.按照先序的次序生成一颗二叉树\n";
cout<<"2.递归算法实现二叉树的先序遍历，输出各结点值\n";
cout<<"3.用非递归算法实现二叉树的遍历，输出各结点值\n";
cout<<"4.求度分别为0、1、2的结点的数目（递归算法实现）\n";
cout<<"5.求度分别为0、1、2的结点的数目（非递归算法实现）\n";
cout<<"6.按层次遍历二叉树\n";
cout<<"7.求二叉树的高度(深度)\n";
cout<<"8.判断是否为完全二叉树，输出\"Yes!\"或\"No!\"\n";
cout<<"9.交换每个结点的左右子树\n";
cout<<"10.对交换左右子树后的二叉树作中序遍历\n";
cout<<"11.退出\n";
cin>>choice;
switch(choice)
{
case 1:
create_BiTree(T);
break;
case 2:
pre_order_traverse3(T);
break;
case 3:
in_order_traverse2(T);
break;
case 4:
get_node(T);
break;
case 5:
get_node_1(T);
break;
case 6:
level_order_traverse2(T);
break;
case 7:
cout<<"二叉树的高度为%d\n"<<height(T)<<endl;
break;
case 8:
if(judge(T)==0)
cout<<"No\n"<<endl;
else
cout<<"Yes\n"<<endl;
break;
case 9:
exchange(T);
break;
case 10:
in_order_traverse(T);
break;
}
}while(choice!=11);
}