二叉树的几个相关算法


#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);   
}

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值