二叉树的各种遍历操作

最新推荐文章于 2022-03-09 20:28:02 发布

原创最新推荐文章于 2022-03-09 20:28:02 发布 · 1k 阅读

2 ·

CC 4.0 BY-SA版权

文章标签：

#二叉树 #遍历

数据结构专栏收录该内容

5 篇文章

订阅专栏

本文深入探讨了二叉树的前序、中序和后序遍历方法，包括递归和非递归实现，同时介绍了层次遍历，并提供了详细的代码示例，帮助读者全面理解二叉树的遍历操作。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

 作    者：王鹏 
 * 完成日期：2016年 3 月 13 日  
 * 问题描述：二叉树的各种遍历操作  
 * 输入描述：以#代替树的儿子为空，如输入（ABD##FE###CG#H##I##）. 
 * 程序输出：如代码所示

#include<stdio.h>
#include<stdlib.h>

typedef struct TreeNode *BiTree;
typedef struct TreeNode  BiTNode;

 struct TreeNode{
	char data;
	BiTree Left;
	BiTree Right;
}; 


typedef struct Node{
	BiTree data;
	struct Node *Next;

}Stack;

typedef struct NodeQ{
	BiTree data;
	struct NodeQ *Next;

}Queue;

typedef struct queue{
	Queue *front;
	Queue *rear;
}LinkQueue;

 
//栈函数的声明 
Stack *CreateStack();
int IsEmpty(Stack *s);
BiTree Pop(Stack *s);
void Push(Stack *s, BiTree item);


//队列函数的声明
void CreateQueue(LinkQueue *Q);
int IsEmptyQ(LinkQueue *Q);
int AddQ(LinkQueue *Q, BiTree e);
BiTree Delete(LinkQueue *Q);


// 树函数的声明
BiTree CreatBiTree();                      //按先序遍历创建二叉树 
void PreOrder_1(BiTree T);                 //先序遍历（递归） 
void InOrder_1(BiTree T);                  //中序遍历（递归）
void PostOrder_1(BiTree T);                //后序遍历（递归） 
void PreOrder_2(BiTree BT);                //先序遍历（非递归） 
void InOrder_2(BiTree BT);                 //中序遍历（非递归）
void PostOrder_2(BiTree BT);               //后序遍历（非递归） 
void LevelOrder(BiTree BT);                //层序遍历（非递归） 
int depth(BiTree T);                       //计算树的深度 
void CoutNode(BiTree T);                   //输出所有树的叶节点 

 
int main()
{
	BiTree T;

	int flag = 1, i ;
	
	    printf("                 本程序实现二叉树的基本操作。                           \n");
	    printf("可以进行建立二叉树，分别用递归与非递归的算法进行二叉树的3种遍历。       \n"); 
	
	while(flag){
		
		printf("|                                                                      |\n"); 
		printf("|**********************************************************************|\n");
		printf("|                        二叉树的基本操作如下：                        |\n");
		printf("|                           0.创建二叉树                               |\n");
		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("|                                                                      |\n"); 
		printf("|**********************************************************************|\n");
		printf("|                                                                      |\n"); 
		printf("|                           请选择功能：                               |\n"); 
		
		scanf("%d", &i);   
		                      //输入需要选择的功能 
		switch(i){
			case 0:
				printf("请以先序的方式输入二叉树（#代表NULL）:");
				T = CreatBiTree();
				break; 
				
			case 1:
				if(T){
					printf("先序遍历（递归）的结果为：");
					PreOrder_1(T);
					printf("\n");
				}else
				    printf("       二叉树为空！\n");
				break;	 
				
			case 2:
				if(T){
					printf("中序遍历（递归）的结果为：");
					InOrder_1(T);
					printf("\n"); 
				}else
				    printf("       二叉树为空！\n");
				break;	
				   
			case 3:
				if(T){
					printf("后序遍历（递归）的结果为：");
					PostOrder_1(T);
					printf("\n"); 	
				}else
				    printf("       二叉树为空！\n");
				break;	
				
			case 4:
				if(T){
					printf("先序遍历（非递归）的结果为：");
					PreOrder_2(T);
					printf("\n"); 
				}else
				    printf("       二叉树为空！\n");
				break;	
				
			case 5:
				if(T){
					printf("中序遍历（非递归）的结果为：");
					InOrder_2(T);
					printf("\n"); 
				}else
				    printf("       二叉树为空！\n");
				break;	
				
			case 6:
				if(T){
					printf("后序遍历（非递归）的结果为：");
					PostOrder_2(T);
					printf("\n"); 
				}else
				    printf("       二叉树为空！\n");
				break;	
				
			case 7:
				 if(T){
					printf("层序遍历（非递归）的结果为：");
					LevelOrder(T);
					printf("\n"); 
				}else
				    printf("       二叉树为空！\n");
				break;	
					
			case 8:
				if(T){
					printf("这课二叉树的深度为：%d\n", depth(T));
				}else
				    printf("       二叉树为空！\n");
				break;	
				
			case 9:
				if(T){
					printf("这课二叉树的所有叶节点为:");
					CoutNode(T);
					
				}else
				    printf("       二叉树为空！\n");
				break;	
		
			default:
			    flag = 0;
				printf("程序运行结束，按任意键退出！\n");	
		}  
		
	}
	return 0;
} 

//树的函数 
BiTree CreatBiTree()                    //创建树 
{
	char ch;
	BiTree T; 
	
	scanf("\n%c", &ch);
	if(ch =='#')
	   T = NULL;
	else{
		if(!(T = (BiTree)malloc(sizeof(BiTNode))))
		   exit(-1);
		T->data  = ch;
		T->Left = CreatBiTree(); 
		T->Right = CreatBiTree();
	}   
	return T; 
}


void PreOrder_1(BiTree T)               //先序遍历（递归） 
{
	if(T){
	
		printf("%c", T->data);
		PreOrder_1(T->Left);
		PreOrder_1(T->Right);
	}
 } 
 
 void InOrder_1(BiTree T)              //中序遍历（递归） 
 {
 	if(T){
		InOrder_1(T->Left);
		printf("%c", T->data);
		InOrder_1(T->Right);
	}
  }
  
 void PostOrder_1(BiTree T)            //后序遍历（递归） 
 {
 	if(T){
		PostOrder_1(T->Left);
		PostOrder_1(T->Right);
		printf("%c", T->data);
	}
  }  
  
  void PreOrder_2(BiTree BT)           //先序遍历（非递归） 
  {
  	BiTree T = BT;
  	Stack *s = CreateStack();
  	while(T || !IsEmpty(s)){
  		while(T){
  			Push(s, T);
  			printf("%c", T->data);
  			T = T->Left;
		  }
		  
		if(!IsEmpty(s)){
		
			T= Pop(s);
			T = T->Right ;
		}  
	  }
  }
  
  void InOrder_2(BiTree BT)            //中序遍历（非递归） 
  {
  	BiTree T = BT;
  	Stack *s = CreateStack();
  	while(T || !IsEmpty(s)){
  		while(T){
  			Push(s, T);
  			T = T->Left;
		  }
		  
		if(!IsEmpty(s)){
			T = Pop(s);
			printf("%c", T->data);
			T = T->Right ;
		}  
	  }
  }
  
  void PostOrder_2(BiTree BT)         //后序遍历（非递归） 
  {
  	BiTree T = BT;
  	Stack *s1 = CreateStack();
  	Stack *s2 = CreateStack();
  	Push(s1, T);
  	while(!IsEmpty(s1)){
  		T = Pop(s1);
  		Push(s2, T);
  		if(T->Left )     Push(s1, T->Left);
  		if(T->Right)     Push(s1, T->Right);
  		
	  }
	while(!IsEmpty(s2)){
		T = Pop(s2);
		printf("%c", T->data);
	}  
  	
   } 
   
void LevelOrder(BiTree BT)           //层序遍历（非递归） 
{
    LinkQueue Q;
	BiTree T;

	if(!BT)     return;   //空树返回	
	CreateQueue(&Q);
	AddQ(&Q, BT);
	while(!IsEmptyQ(&Q)){
		
		T = Delete(&Q);
		printf("%c", T->data );
		if(T->Left )     AddQ(&Q, T->Left );
		if(T->Right )    AddQ(&Q, T->Right );
	} 
}


int depth(BiTree T)                   //计算树的深度 
{
	int HL, HR, MaxH;
	if(T){
		HL = depth(T->Left );
		HR = depth(T->Right  );
		MaxH = (HL > HR) ? HL : HR; 
		return (MaxH + 1);
	}else
	    return 0;

}
void CoutNode(BiTree T)              //输出所有树的叶节点 
{   
    
	if(T){
		if(!T->Left && !T->Right ){
		   printf("%c", T->data );
	}
		CoutNode( T->Left );    
		CoutNode( T->Right );    
	}
}

   
   
//栈的函数  
Stack *CreateStack()                  //创建栈 
{
	Stack *s;
	if(!(s = (Stack *)malloc(sizeof(struct Node))))
	   exit(-1);
	s->Next = NULL;
    return s;	
}

int IsEmpty(Stack *s)                 //判断栈是否为空 
{
	return (s->Next == NULL);
}

void Push(Stack *s, BiTree item)      //入栈 
{
	Stack *TmpCell;
	if(!(TmpCell = (Stack *)malloc(sizeof(struct Node))))
	    exit(-1);
	TmpCell->data = item;
	TmpCell->Next = s->Next;
	s->Next = TmpCell; 
}

BiTree Pop(Stack *s)                  //出栈 
{
	struct Node *FirstCell;
	BiTree TopElem;
	
	if(IsEmpty(s)){
		printf("堆栈空");   return NULL; 
	}else{
		FirstCell = s->Next ;
		s->Next = FirstCell->Next;
		TopElem = FirstCell->data;
		free(FirstCell);
		return TopElem;
	}
	
}

//队列的函数
void CreateQueue(LinkQueue *Q)                 //创建队列 
{

    if(!(Q->front = Q->rear = (Queue*)malloc(sizeof(struct NodeQ))))
        exit(-1);
	Q->front->Next = NULL; 

 } 

 int IsEmptyQ(LinkQueue *Q)                   //判断队列是否为空 
 {
 	if(Q->front == Q->rear )
 	    return 1;
 	else
 	    return 0;
  } 
  
 int AddQ(LinkQueue *Q, BiTree e)             //入队列
 {
 	Queue *p;
 	if(!(p = (Queue *)malloc(sizeof(struct NodeQ))))
 	   exit(-1);
 	p->data = e;
	p->Next = NULL;
	Q->rear->Next = p;
	Q->rear = p;
	return 0; 
  } 
  
 BiTree Delete(LinkQueue *Q)                  //出队列
 {
 	Queue *p;
 	BiTree e;
 	if(IsEmptyQ(Q)){
       printf("队列为空");   return NULL; 
    }else{
	p = Q->front->Next ; 
	e = p->data ;
 	Q->front->Next = p->Next ;
 	if(Q->rear == p)
 	   Q->rear = Q->front ;
 	free(p);
	 return e;   
  } 
}