数据结构 二叉树

实验题目： 二叉树的基本操作实现               

实验环境：    Visual C++ 6.0                   　

实验目的：掌握二叉树的二叉链存储结构及表示。

          掌握二叉树的三种遍历算法（递归和非递归两类）。

          运用三种遍历的方法求解二叉树的有关问题。

实验内容：实现二叉树的二叉链表存储结构；

          实现先序、中序和后序遍历二叉树；

          遍历二叉树的应用:计算叶子结点、左右子树交换等。

 

要求：1、二叉树基本操作已实现，学习和进一步理解。

      2 、在求总结点的程序中加入求叶子结点的功能。

      3 、左右子树交换,按中序和后序是否也可以？

      4 、选作：按层遍历二叉树。

#include<stdio.h>
#include<malloc.h>
#include<stdlib.h>
#include<string.h>
#define MAXSIZE 100
#define MAXSIZES 10
#define OK 1
#define ERROR 0
#define OVERFLOW -2
typedef int Status;
typedef char TElemType;
typedef struct BiTNode//二叉树的二叉链表储存表示 
{
	TElemType data;//节点数据域 
	struct BiTNode *lchild,*rchild;//左右孩子指针 
}BiTNode,*BiTree,*SElemType;
typedef struct//顺序栈的储存结构 
{
	SElemType *base;
	SElemType *top;
	int stacksize; 
}SqStack;
Status InitStack(SqStack &S)//初始化 
{
	S.base=(SElemType *)malloc(sizeof(SElemType)*MAXSIZE);
	if(!S.base)
	    exit(OVERFLOW);
	S.top=S.base;
	S.stacksize=MAXSIZE;
	return OK;
}
Status Push(SqStack &S,BiTree e)//入栈 
{
	if(S.top-S.base>=S.stacksize)
	{
		S.base=(SElemType *)realloc(S.base,(S.stacksize+MAXSIZES)*sizeof(SElemType));
		if(!S.base)
		   exit(OVERFLOW);
		S.top=S.base+S.stacksize;
		S.stacksize+=MAXSIZES;
	}
    *S.top++=e;
    return OK;
}
BiTree GetTop(SqStack S)
{
	if(S.top!=S.base)
	   return *(S.top-1);
}
Status Pop(SqStack &S,BiTree &e)//出栈 
{
	if(S.top==S.base)
	   return ERROR;
	e=*--S.top;
	return OK;
}
Status StackEmpty(SqStack S)//判断栈是否为空 
{
	if(S.top==S.base)
	   return OK;
	return ERROR;
}
void CreateBitree(BiTree &T)//按先序次序输入二叉树中部分节点的值（一个字符）
{//创建二叉链表示的二叉树
	char ch;
	scanf("%c",&ch);
	//ch=getchar();
	if(ch=='#') 
	   T=NULL;//建空树 
	else //递归创建二叉树 
	{
		if(!(T=(BiTNode *)malloc(sizeof(BiTNode))))
		    exit(OVERFLOW);
		T->data=ch;//将根节点的数据域置为ch 
		CreateBitree(T->lchild);//递归创建左子树 
		CreateBitree(T->rchild);//递归创建右子树 
	}
}
void InOrderTraverse(BiTree T)//中序遍历二叉树T的递归算法 
{
	if(T)
	{
		InOrderTraverse(T->lchild);
		printf("%c",T->data);
		InOrderTraverse(T->rchild);
	}
}
void  PreOrderTraverse(BiTree T)//先序遍历二叉树T的递归算法 
{
	if(T)
	{
		printf("%c",T->data);
		PreOrderTraverse(T->lchild);
		PreOrderTraverse(T->rchild);
	}
}
void  PostOrderTraverse(BiTree T)//后序遍历二叉树T的递归算法 
{
	if(T)
	{
		PostOrderTraverse(T->lchild);
		PostOrderTraverse(T->rchild);
		printf("%c",T->data);
	}
}
void FInOrderTraverse(BiTree T)//中序遍历二叉树T的非递归算法 
{
	SqStack S;
	BiTree p;
	InitStack(S);
	p=T;
	while(p||!StackEmpty(S))
	{
		if(p)//p非空 
		{
			Push(S,p);//根指针进栈 
			p=p->lchild;//遍历左子树 
		 }
		 else//p为空 
		 {
		 	Pop(S,p);//出栈 
		 	printf("%c",p->data);//访问根节点 
		 	p=p->rchild;//遍历右子树 
		 }
	}
}
void  FPreOrderTraverse(BiTree T)//先序遍历二叉树T的非递归算法
{
	SqStack S;
	BiTree p;
	InitStack(S);
	p=T;
	while(p||!StackEmpty(S))
	{
		if(p)
		{
			printf("%c",p->data);
			Push(S,p);
			p=p->lchild;
		}
		else
		{
			Pop(S,p);
			p=p->rchild;
		}
	} 
}
void FPostOrderTraverse(BiTree T)//后序非递归遍历二叉树 
{  
    if (!T) return;  
    SqStack S,output;
    BiTree  p;
    InitStack(S);
    InitStack(output);
    Push(S,T);  
    while(!StackEmpty(S))
	{  
        Pop(S,p);
		Push(output,p);  
        if (p->lchild)  
            Push(S,p->lchild);  
        if (p->rchild)  
            Push(S,p->rchild);  
    }  
      
    while (!StackEmpty(output)) 
    
	{  
	    Pop(output,p); 
        printf("%c",p->data);
    }  
}  
int NodeCount(BiTree T)//统计二叉树T中节点的个数 
{
	if(T==NULL)//空树，节点的个数为0 
	   return 0;
	else//节点的个数=左子树节点的个数+右子树节点的个数+1 
	   return NodeCount(T->lchild)+NodeCount(T->rchild)+1;
}
int LeafNodeCount(BiTree T)//统计二叉树中叶子节点的个数 
{
	int sum=0,m,n;
	if(T)
	{
		if((!T->lchild)&&(!T->rchild))//为叶子 节点 
		    sum++;
		m=LeafNodeCount(T->lchild);//左子树上的叶子节点 
		n=LeafNodeCount(T->rchild);//右子树上的叶子节点 
		sum=sum+m+n;
	 } 
	 return sum;
}
void Exchange(BiTNode *T)//交换每个节点的左孩子和右孩子 
{
	BiTNode *temp;
	if(T==NULL)
	   return ;
	Exchange(T->lchild);//左子树 交换 
	Exchange(T->rchild);//右子树 交换 
	temp=T->lchild;//交换当前节点的左右子树 
	T->lchild=T->rchild;
	T->rchild=temp;
 } 
int main()
{
	BiTree T;
	int sum,leafsum,choose;
	printf("1. 创建二叉树\n");
	printf("2. 中序递归遍历二叉树\n");
	printf("3. 先序递归遍历二叉树\n");
	printf("4. 后序递归遍历二叉树\n");
	printf("5. 中序非递归遍历二叉树\n");
	printf("6. 先序非递归遍历二叉树\n");
	printf("7. 后序非递归遍历二叉树\n");
	printf("8. 输出总的节点数\n");
	printf("9. 输出叶子节点的个数\n");
	printf("10. 交换每个节点的左孩子和右孩子\n");
	printf("0. 退出\n\n");
	choose=-1;
	while(choose!=0)
	{
		printf("请选择:");
		scanf("%d",&choose);
		switch(choose)
		{
		    case 1:
			    printf("请输入你所要建立的二叉树\n");
	            printf("例如输入序列“ABC##DE#G##F###”其中#表示空\n");
	            CreateBitree(T);
	            break;
	       case 2:
			    InOrderTraverse(T);
			    break;
		    case 3:
		    	PreOrderTraverse(T);
		    	break;
		    case 4:
		    	PostOrderTraverse(T);
		    	break;
		    case 5:
		    	FInOrderTraverse(T);
		    	break;
		    case 6:
			    FPreOrderTraverse(T);
			    break;
			case 7:
			    FPostOrderTraverse(T);
			    break;
			case 8: 
			    sum=NodeCount(T);  
		    	printf("%d\n",sum);
		    	break;
		    case 9:
		    	leafsum=LeafNodeCount(T);
		    	printf("%d\n",leafsum);
		    	break;
		    case 10:
			    Exchange(T);
			    break;
		}	    
    }
    return 0;
}