二叉樹應用

阿新 • • 發佈：2018-12-05

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

#define OK 			1
#define ERROR 		0
#define MAXSIZE 	50
#define OVERFLOW	-1

typedef int Status; 
typedef char TElemType;
char m;
typedef struct BiTNode
{
	TElemType		data;
	struct BiTNode	*lchild, *rchild; 				
} BiTNode, *BiTree;


Status InitBiTree(BiTree &T)						//構造空二叉樹T
{ 
	T=NULL;
	return OK;
}

void DestroyBiTree(BiTree &T)						//後序銷燬二叉樹T
{ 
	if(T)
	{
    	if(T->lchild) DestroyBiTree(T->lchild); 	
     	if(T->rchild) DestroyBiTree(T->rchild); 	
     	free(T); 										
     	T=NULL; 											
   	}
}

void CreateBiTree(BiTree &T)						//先序建立二叉樹 
{ 
   	TElemType	ch;
   	scanf("%c",&ch);
   	if(ch==' ') T=NULL;
   	else
	{
     	T=(BiTNode *)malloc(sizeof(BiTNode));
     	if(!T) exit(OVERFLOW);
    	T->data=ch; 										
    	CreateBiTree(T->lchild); 					
     	CreateBiTree(T->rchild); 					
  	}
}

void PreOrderTraverse(BiTree T)						// 先序遍歷遞迴 
{ 
	if(T)
	{
     	printf("%c ",T->data); 							
     	PreOrderTraverse(T->lchild);				 	
     	PreOrderTraverse(T->rchild); 			
   	}
}

void InOrderTraverse(BiTree T)						// 中序遍歷遞迴 
{
   	if(T)
	{
    	 InOrderTraverse(T->lchild);  		
    	 printf("%c ",T->data); 					
    	 InOrderTraverse(T->rchild);  			
   	}
}

void PostOrderTraverse(BiTree T)					// 後序遍歷遞迴 
{
   if(T)
   {
     	PostOrderTraverse(T->lchild); 	
   	  PostOrderTraverse(T->rchild); 		
    	 printf("%c ",T->data);  				
   }
}


// 中序遍歷非遞迴遍歷演算法
void InOrderTraversal_NoRecursion( BiTNode *T )
{   
		BiTNode	 *Stack[MAXSIZE];
		int	 top=-1;				
		while(T || (top!=-1))		// T為空指標或者棧為空時終止。棧中不壓入空指標。
		{
		    while(T)						// 一直向左並將沿途結點壓入堆疊
		    {   
		        Stack[++top] = T; 
		        T=T->lchild; 
		    }		    
		    if(top!=-1)
		    {
				    T=Stack[top--]; 									// 結點彈出堆疊
				    printf("%c ",T->data); 						//（訪問）列印結點
				    T=T->rchild; 											// 轉向右子樹
		    }
		}
				
}

void find(BiTree T)
{
	if(T)
	{
     	if(T->data==m)
		{
			if(T->lchild==NULL && T->rchild==NULL) printf("沒有左右孩子\n");
			else if(T->lchild==NULL && T->rchild!=NULL) printf("沒有左孩子 右孩子 %c \n",T->rchild->data);
			else if(T->lchild!=NULL && T->rchild==NULL) printf("左孩子%c  沒有右孩子\n",T->lchild->data);
			else 
			{
				printf("左孩子 %c ",T->lchild->data);
				printf("右孩子 %c \n",T->rchild->data);
			}
		}						
     	find(T->lchild);				 	
     	find(T->rchild); 			
   	}
}						
 
void PreOrdershow(BiTree T)						// 先序遍歷廣義表輸出 
{ 
	if(T)
	{	 
		if(T->lchild==NULL && T->rchild==NULL)
		{
			printf("%c",T->data);
			return;
		}
		if(T->lchild!=NULL || T->rchild!=NULL)
		{
			printf("%c(",T->data); 
		}
		
		if(T->lchild==NULL && T->rchild==NULL)
		{
			printf("%c",T->data);
		}
		PreOrdershow(T->lchild); 
		if(T->rchild!=NULL)
		{
			printf(",");
		}
		PreOrdershow(T->rchild);
		if(T->lchild!=NULL || T->rchild!=NULL)
		{
			printf(")");
		}		
									
   	}
}

void PreOrdershow1(BiTree T)  				//先序遍歷廣義表輸出 高階寫法  又上一個總結到這個 
{
	if(T)
	{
		printf("%c",T->data);
		if(T->lchild!=NULL || T->rchild!=NULL)
		{
			printf("(");
			DispBTree(T->lchild);
			if(T->rchild!=NULL) printf(",");
			DispBTree(T->rchild);
			printf(")");
		}
	}
}

int max(int a, int b)
{
	return a>=b ? a : b;
}

int	BTree_Height(BiTree T)											//高度 
{
	if(T==NULL)
		return	0;
	else
		if(T->lchild==NULL && T->rchild==NULL)
			return	1;
		else
			return	1+max(BTree_Height(T->lchild),BTree_Height(T->rchild));
}

void PreOrderPrintLeaves(BiTree T)			// 輸出葉子結點值
{
    if(T) 
    {
        if(T->lchild==NULL && T->rchild==NULL)
    		printf("%c ",T->data );
        PreOrderPrintLeaves (T->lchild);
        PreOrderPrintLeaves (T->rchild);
    }
}


int	main()
{
	BiTree	root; 
	printf("建立二叉樹\n");
	InitBiTree(root);
	CreateBiTree(root);
	printf("\n");
	
	printf("輸出二叉樹\n");//"ABD  EHJ  KL  M N   CF  G I  " 
	PreOrdershow(root);printf("\n");
	PreOrdershow1(root);
	printf("\n\n");

	printf("查詢H節點\n");
	m='H';
	find(root);
	printf("\n\n");
	
	printf("二叉樹高度\n");
	printf("%d",BTree_Height(root));
	printf("\n\n");
	
	printf("釋放二叉樹\n");
	DestroyBiTree(root);			
}

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

#define OK 			1
#define ERROR 		0
#define MAXSIZE 	50
#define OVERFLOW	-1

typedef int Status; 
typedef char TElemType;
char m;
typedef struct BiTNode
{
	TElemType		data;
	struct BiTNode	*lchild, *rchild; 				
} BiTNode, *BiTree;


Status InitBiTree(BiTree &T)						//構造空二叉樹T
{ 
	T=NULL;
	return OK;
}

void DestroyBiTree(BiTree &T)						//後序銷燬二叉樹T
{ 
	if(T)
	{
    	if(T->lchild) DestroyBiTree(T->lchild); 	
     	if(T->rchild) DestroyBiTree(T->rchild); 	
     	free(T); 										
     	T=NULL; 											
   	}
}

void CreateBiTree(BiTree &T)						//先序建立二叉樹 
{ 
   	TElemType	ch;
   	scanf("%c",&ch);
   	if(ch==' ') T=NULL;
   	else
	{
     	T=(BiTNode *)malloc(sizeof(BiTNode));
     	if(!T) exit(OVERFLOW);
    	T->data=ch; 										
    	CreateBiTree(T->lchild); 					
     	CreateBiTree(T->rchild); 					
  	}
}

void PreOrderTraverse(BiTree T)						// 先序遍歷遞迴 
{ 
	if(T)
	{
     	printf("%c ",T->data); 							
     	PreOrderTraverse(T->lchild);				 	
     	PreOrderTraverse(T->rchild); 			
   	}
}

void InOrderTraverse(BiTree T)						// 中序遍歷遞迴 
{
   	if(T)
	{
    	 InOrderTraverse(T->lchild);  		
    	 printf("%c ",T->data); 					
    	 InOrderTraverse(T->rchild);  			
   	}
}

void PostOrderTraverse(BiTree T)					// 後序遍歷遞迴 
{
	if(T)
	{
    	 PostOrderTraverse(T->lchild); 	
    	 PostOrderTraverse(T->rchild); 		
    	 printf("%c ",T->data);  				
  	}
}

void PreOrderTraverse_NoRecursion(BiTNode *T)				// 先序遍歷非遞迴遍歷演算法
{   
		BiTNode	 *Stack[MAXSIZE];
		int	 top=-1;				
		while(T || (top!=-1))		
		{
		    while(T)					
		    {   
		        Stack[++top]=T;
				printf("%c ",T->data);  
		        T=T->lchild; 
		    }		    
		    if(top!=-1)
		    {
				T=Stack[top--]; 								
				T=T->rchild; 										
		    }
		}
				
}

void InOrderTraversal_NoRecursion(BiTNode *T)				// 中序遍歷非遞迴遍歷演算法
{   
		BiTNode	 *Stack[MAXSIZE];
		int	 top=-1;				
		while(T || (top!=-1))		// T為空指標或者棧為空時終止。棧中不壓入空指標。
		{
		    while(T)						// 一直向左並將沿途結點壓入堆疊
		    {   
		        Stack[++top]=T; 
		        T=T->lchild; 
		    }		    
		    if(top!=-1)
		    {
				T=Stack[top--]; 									// 結點彈出堆疊
				printf("%c ",T->data); 								//（訪問）列印結點
				T=T->rchild; 										// 轉向右子樹
		    }
		}
				
}

void PostOrderTraversal_NoRecursion(BiTNode *T)				// 後序遍歷非遞迴遍歷演算法
{   
		BiTNode	 *Stack[MAXSIZE];
		int Stack1[MAXSIZE];
		int	 top=-1;int tag;				
		while(T || (top!=-1))		
		{
		    while(T)						
		    {   
		        Stack[++top]=T;
				tag=0;
				Stack1[top]=tag;
		        T=T->lchild; 
		    }	
			if(Stack1[top]==0)
			{
				tag=1;
				Stack1[top]=tag;
				T=Stack[top]->rchild;
			}
			else
			{
				T=Stack[top];
				top--;
				printf("%c ",T->data);
				T=NULL; 	
			}	    
		   
		}
				
}

void LevelorderTraverse(BiTNode *T)
{  
	BiTNode *Queue[MAXSIZE];
	int front=0,rear=0;
	if(T) 
	{ 
		Queue[++rear]=T;    							/*   根結點入隊  */
		while(front<rear)
	    {  
			T=Queue[++front];  
			printf("%c ",T->data);
	        if(T->lchild!=NULL)
	            Queue[++rear]=T->lchild;   			 /*   左結點入隊  */
	        if(T->rchild!=NULL)
	            Queue[++rear]=T->rchild;   			 /*   右結點入隊  */
	    }
	      
	}
}


void find(BiTree T)
{
	if(T)
	{
     	if(T->data==m)
		{
			if(T->lchild==NULL && T->rchild==NULL) printf("沒有左右孩子\n");
			else if(T->lchild==NULL && T->rchild!=NULL) printf("沒有左孩子 右孩子 %c \n",T->rchild->data);
			else if(T->lchild!=NULL && T->rchild==NULL) printf("左孩子%c  沒有右孩子\n",T->lchild->data);
			else 
			{
				printf("左孩子 %c ",T->lchild->data);
				printf("右孩子 %c \n",T->rchild->data);
			}
		}						
     	find(T->lchild);				 	
     	find(T->rchild); 			
   	}
}						
 
void PreOrdershow(BiTree T)						// 先序遍歷廣義表輸出 
{ 
	if(T)
	{	 
		if(T->lchild==NULL && T->rchild==NULL)
		{
			printf("%c",T->data);
			return;
		}
		if(T->lchild!=NULL || T->rchild!=NULL)
		{
			printf("%c(",T->data); 
		}
		
		if(T->lchild==NULL && T->rchild==NULL)
		{
			printf("%c",T->data);
		}
		PreOrdershow(T->lchild); 
		if(T->rchild!=NULL)
		{
			printf(",");
		}
		PreOrdershow(T->rchild);
		if(T->lchild!=NULL || T->rchild!=NULL)
		{
				printf(")");
		}		
		
		
					
   	}
}

int max(int a, int b)
{
	return a>=b ? a : b;
}

int	BTree_Height(BiTree T)											//高度 
{
	if(T==NULL)
		return	0;
	else
		if(T->lchild==NULL && T->rchild==NULL)
			return	1;
		else
			return	1+max(BTree_Height(T->lchild),BTree_Height(T->rchild));
}

void PreOrderPrintLeaves(BiTree T)			// 輸出葉子結點值
{
    if(T) 
    {
        if(T->lchild==NULL && T->rchild==NULL)
    		printf("%c ",T->data );
        PreOrderPrintLeaves (T->lchild);
        PreOrderPrintLeaves (T->rchild);
    }
}


int	main()
{
	BiTree	root; 
	printf("建立二叉樹\n");
	InitBiTree(root);
	CreateBiTree(root);

	printf("輸出二叉樹\n");//"ABD  EHJ  KL  M N   CF  G I  " 
	PreOrdershow(root);
	printf("\n");

	printf("層次遍歷二叉樹-遞迴\n");
	 LevelorderTraverse(root);
	printf("\n");
	
	printf("先序遍歷二叉樹-遞迴\n");
	PreOrderTraverse(root);
	printf("\n");
	printf("先序遍歷二叉樹-非遞迴\n");
	PreOrderTraverse_NoRecursion(root);
	printf("\n");
	
	printf("中序遍歷二叉樹-遞迴\n");
	InOrderTraverse(root);
	printf("\n");
	printf("中序遍歷二叉樹-非遞迴\n");
	InOrderTraversal_NoRecursion(root);
	printf("\n");
	
	printf("後序遍歷二叉樹-遞迴\n");
	PostOrderTraverse(root);
	printf("\n");
	printf("後序遍歷二叉樹-非遞迴\n");
	PostOrderTraversal_NoRecursion(root); 
	printf("\n");
	
	printf("釋放二叉樹\n");
	DestroyBiTree(root);	
	printf("\n");		
}

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

#define OK 			1
#define ERROR 		0
#define MAXSIZE 	50
#define OVERFLOW	-1

typedef int Status; 
typedef char TElemType;
int level;
char m;
typedef struct BiTNode
{
	TElemType		data;
	struct BiTNode	*lchild, *rchild; 				
} BiTNode, *BiTree;


Status InitBiTree(BiTree &T)						//構造空二叉樹T
{ 
	T=NULL;
	return OK;
}

void DestroyBiTree(BiTree &T)						//後序銷燬二叉樹T
{ 
	if(T)
	{
    	if(T->lchild) DestroyBiTree(T->lchild); 	
     	if(T->rchild) DestroyBiTree(T->rchild); 	
     	free(T); 										
     	T=NULL; 											
   	}
}

void CreateBiTree(BiTree &T)						//先序建立二叉樹 
{ 
   	TElemType	ch;
   	scanf("%c",&ch);
   	if(ch==' ') T=NULL;
   	else
	{
    	T=(BiTNode *)malloc(sizeof(BiTNode));
     	if(!T) exit(OVERFLOW);
    	T->data=ch; 										
    	CreateBiTree(T->lchild); 					
     	CreateBiTree(T->rchild); 					
  	}
}

void PreOrderTraverse(BiTree T)						// 先序遍歷遞迴 
{ 
	if(T)
	{
     	printf("%c ",T->data); 							
     	PreOrderTraverse(T->lchild);				 	
     	PreOrderTraverse(T->rchild); 			
   	}
}

void InOrderTraverse(BiTree T)						// 中序遍歷遞迴 
{
   	if(T)
	{
    	 InOrderTraverse(T->lchild);  		
    	 printf("%c ",T->data); 					
    	 InOrderTraverse(T->rchild);  			
   	}
}

void PostOrderTraverse(BiTree T)					// 後序遍歷遞迴 
{
   if(T)
   {
     	PostOrderTraverse(T->lchild); 	
     	PostOrderTraverse(T->rchild); 		
     	printf("%c ",T->data);  				
   }
}

void PreOrderTraverse_NoRecursion(BiTNode *T)				// 先序遍歷非遞迴遍歷演算法
{   
		BiTNode	 *Stack[MAXSIZE];
		int	 top=-1;				
		while(T || (top!=-1))		
		{
		    while(T)					
		    {   
		        Stack[++top]=T;
				printf("%c ",T->data);  
		        T=T->lchild; 
		    }		    
		    if(top!=-1)
		    {
				T=Stack[top--]; 								
				T=T->rchild; 										
		    }
		}
				
}

void InOrderTraversal_NoRecursion(BiTNode *T)				// 中序遍歷非遞迴遍歷演算法
{   
		BiTNode	 *Stack[MAXSIZE];
		int	 top=-1;				
		while(T || (top!=-1))		// T為空指標或者棧為空時終止。棧中不壓入空指標。
		{
		    while(T)						// 一直向左並將沿途結點壓入堆疊
		    {   
		        Stack[++top]=T; 
		        T=T->lchild; 
		    }		    
		    if(top!=-1)
		    {
				T=Stack[top--]; 									// 結點彈出堆疊
				printf("%c ",T->data); 								//（訪問）列印結點
				T=T->rchild; 										// 轉向右子樹
		    }
		}
				
}

void PostOrderTraversal_NoRecursion(BiTNode *T)				// 後序遍歷非遞迴遍歷演算法
{   
		BiTNode	 *Stack[MAXSIZE];
		int Stack1[MAXSIZE];
		int	 top=-1;int tag;				
		while(T || (top!=-1))		
		{
		    while(T)						
		    {   
		        Stack[++top]=T;
				tag=0;
				Stack1[top]=tag;
		        T=T->lchild; 
		    }	
			if(Stack1[top]==0)
			{
				tag=1;
				Stack1[top]=tag;
				T=Stack[top]->rchild;
			}
			else
			{
				T=Stack[top];
				top--;
				printf("%c ",T->data);
				T=NULL; 	
			}	    
		   
		}
				
}

void LevelorderTraverse(BiTNode *T)
{  
	BiTNode *Queue[MAXSIZE];
	int front=0,rear=0;
	if(T) 
	{ 
		Queue[++rear]=T;    							/*   根結點入隊  */
		while(front<rear)
	    {  
			T=Queue[++front];  
			printf("%c ",T->data);
	        if(T->lchild!=NULL)
	            Queue[++rear]=T->lchild;   			 /*   左結點入隊  */
	        if(T->rchild!=NULL)
	            Queue[++rear]=T->rchild;   			 /*   右結點入隊  */
	    }
	      
	}
}


void find_address(BiTree &T) //"ABD  EHJ  KL  M N   CF  G I  " 
{
	if(T) 						
	{
		if(T->data==m)
		{
			if(T->lchild==NULL && T->rchild==NULL) printf("沒有左右孩子");
			else if(T->lchild==NULL && T->rchild!=NULL) printf("沒有左孩子 右孩子 %c ",T->rchild->data);
			else if(T->lchild!=NULL && T->rchild==NULL) printf("左孩子%c  沒有右孩子",T->lchild->data);
			else 
			{
				printf("左孩子 %c ",T->lchild->data);
				printf("右孩子 %c ",T->rchild->data);
			}
			printf("   查詢節點所在層次%d \n",level); 
		}	
		level++;				
    	find_address(T->lchild);				 	
    	find_address(T->rchild);
		level--; 	
   	}
}						
 
void PreOrdershow(BiTree T)						// 先序遍歷廣義表輸出 
{ 
	if(T)
	{	 
		if(T->lchild==NULL && T->rchild==NULL)
		{
			printf("%c",T->data);
			return;
		}
		if(T->lchild!=NULL || T->rchild!=NULL)
		{
			printf("%c(",T->data); 
		}
		
		if(T->lchild==NULL && T->rchild==NULL)
		{
			printf("%c",T->data);
		}
		PreOrdershow(T->lchild); 
		if(T->rchild!=NULL)
		{
			printf(",");
		}
		PreOrdershow(T->rchild);
		if(T->lchild!=NULL || T->rchild!=NULL)
		{
			printf(")");
		}		
		
		
					
	}
}

int max(int a, int b)
{
	return a>=b ? a:b;
}

int	BTree_Height(BiTree T)											//高度 
{
	if(T==NULL)
		return	0;
	else
		if(T->lchild==NULL && T->rchild==NULL)
			return	1;
		else
			return	1+max(BTree_Height(T->lchild),BTree_Height(T->rchild));
}

void PreOrderPrintLeaves(BiTree T)			// 輸出葉子結點值
{
    if(T) 
    {
        if(T->lchild==NULL && T->rchild==NULL)
    		printf("%c ",T->data );
        PreOrderPrintLeaves (T->lchild);
        PreOrderPrintLeaves (T->rchild);
    }
}


int	main()
{
	BiTree	root; 
	printf("建立二叉樹\n");
	InitBiTree(root);
	CreateBiTree(root);
	printf("\n");

	printf("輸出二叉樹\n");//"ABD  EHJ  KL  M N   CF  G I  " 
	PreOrdershow(root);
	printf("\n\n");

	printf("查詢定位\n");
	m='G';
	find_address(root);	
	printf("\n\n");

	
	printf("釋放二叉樹\n");
	DestroyBiTree(root);	
	printf("\n");		
}

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

#define OK 			1
#define ERROR 		0
#define MAXSIZE 	50
#define OVERFLOW	-1

typedef int Status; 
typedef char TElemType;
char m;
typedef struct BiTNode
{
	TElemType		data;
	struct BiTNode	*lchild, *rchild; 				
} BiTNode, *BiTree;

Status InitBiTree(BiTree &T)						//構造空二叉樹T
{ 
	T=NULL;
	return OK;
}

void DestroyBiTree(BiTree &T)						//後序銷燬二叉樹T
{ 
	if(T) 		
	{
    	if(T->lchild) DestroyBiTree(T->lchild); 	
     	if(T->rchild) DestroyBiTree(T->rchild); 	
     	free(T); 										
     	T=NULL; 											
   	}
}

void CreateBiTree(BiTree &T)						//先序建立二叉樹 
{ 
   	TElemType	ch;
   	scanf("%c",&ch);
   	if(ch==' ') T=NULL;
   	else
	{
    	T=(BiTNode *)malloc(sizeof(BiTNode));
     	if(!T) exit(OVERFLOW);
    	T->data=ch; 										
    	CreateBiTree(T->lchild); 					
     	CreateBiTree(T->rchild); 					
  	}
}

void PreOrderTraverse(BiTree T)						// 先序遍歷遞迴 
{ 
	if(T)
	{
	   	printf("%c ",T->data); 							
     	PreOrderTraverse(T->lchild);				 	
     	PreOrderTraverse(T->rchild); 			
   	}
}

void InOrderTraverse(BiTree T)						// 中序遍歷遞迴 
{
   	if(T)					
   	{
    	 InOrderTraverse(T->lchild);  		
    	 printf("%c ",T->data); 					
    	 InOrderTraverse(T->rchild);  			
   	}
}

void PostOrderTraverse(BiTree T)					// 後序遍歷遞迴 
{
	if(T) 		
	{
     	PostOrderTraverse(T->lchild); 	
    	PostOrderTraverse(T->rchild); 		
     	printf("%c ",T->data);  				
   	}
}


// 中序遍歷非遞迴遍歷演算法
void InOrderTraversal_NoRecursion( BiTNode *T )
{   
		BiTNode	 *Stack[MAXSIZE];
		int	 top=-1;				
		while(T || (top!=-1))		// T為空指標或者棧為空時終止。棧中不壓入空指標。
		{
		    while(T)						// 一直向左並將沿途結點壓入堆疊
		    {   
		        Stack[++top] = T; 
		        T=T->lchild; 
		    }		    
		    if(top!=-1)
		    {
				    T=Stack[top--]; 									// 結點彈出堆疊
				    printf("%c ",T->data); 						//（訪問）列印結點
				    T=T->rchild; 											// 轉向右子樹
		    }
		}
				
}

void find(BiTree T)
{
	if(T)
	{
		if(T->data==m)
		{
			if(T->lchild==NULL && T->rchild==NULL) printf("沒有左右孩子\n");
			else if(T->lchild==NULL && T->rchild!=NULL) printf("沒有左孩子 右孩子 %c \n",T->rchild->data);
			else if(T->lchild!=NULL && T->rchild==NULL) printf("左孩子%c  沒有右孩子\n",T->lchild->data);
			else 
			{
				printf("左孩子 %c ",T->lchild->data);
				printf("右孩子 %c \n",T->rchild->data);
			}
		}						
     	find(T->lchild);				 	
     	find(T->rchild); 			
   	}
}						
 
void PreOrdershow(BiTree T)						// 先序遍歷廣義表輸出 
{ 
	if(T) 						
	{	 
		if(T->lchild==NULL && T->rchild==NULL)
		{
			printf("%c",T->data);
			return;
		}
		if(T->lchild!=NULL || T->rchild!=NULL)
		{
			printf("%c(",T->data); 
		}
		
		if(T->lchild==NULL && T->rchild==NULL)
		{
			printf("%c",T->data);
		}
		PreOrdershow(T->lchild); 
		if(T->rchild!=NULL)
		{
			printf(",");
		}
		PreOrdershow(T->rchild);
		if(T->lchild!=NULL || T->rchild!=NULL)
		{
				printf(")");
		}		
		
		
					
   	}
}
int max(int a, int b)
{
	return a>=b ? a : b;
}

int	BTree_Height(BiTree T)											//高度 
{
	if(T==NULL)
		return	0;
	else
		if(T->lchild==NULL && T->rchild==NULL)
			return	1;
		else
			return	1+max(BTree_Height(T->lchild),BTree_Height(T->rchild));
}

int PrintAncestors(BiTree root, char x)							//查詢x並輸逆序出x的祖先 
{
    if (!root)  return 0;
    if (root->data==x)   
	{
		
        printf("%c ",root->data);
        return 1;
	} 
    //如果子樹中可以找到匹配值 那麼此節點肯定是祖先結點
    if (PrintAncestors(root->lchild, x) || PrintAncestors(root->rchild, x))
    {
        printf("%c ", root->data);
        return 1;
    }
    return 0;
}//列印祖先

void LeavestoGra(BiTree T,TElemType path[],int len) 		//所有葉子節點到根節點的逆序列 （先序遍歷 
{   
    if(T!=NULL)
    {   
		if(T->lchild==NULL && T->rchild==NULL)    //輸出棧中所有結點
        {   
            printf("%c->",T->data);
            for(int i=len-1;i>0;i--)
                printf("%c->",path[i]);
            printf("%c\n",path[0]);
        }
        else
        {   path[len++]=T->data;
            LeavestoGra(T->lchild,path,len);
            LeavestoGra(T->rchild,path,len);
        }
    }
}

void MaxPath(BiTree T,TElemType path[],int len,TElemType maxpath[],int &maxlen)
{   
    if(T!=NULL)
    {   
		if(T->lchild==NULL && T->rchild==NULL)    //輸出棧中所有結點值
        {   
			if(len>maxlen) //通過比較求最長路徑
			{
				maxpath[len]=T->data;
				for(int i=len-1;i>=0;i--)
        		maxpath[i]=path[i];
        		maxlen=len+1;
        	}
        }
        else
        { 
			path[len++]=T->data;          //將當前節點放入路徑中   //路徑長度增1
        	MaxPath(T->lchild,path,len,maxpath,maxlen);
        	MaxPath(T->rchild,path,len,maxpath,maxlen);
        }
    }
}

void zhenghe(BiTree T,TElemType path[],int len,TElemType maxpath[],int &maxlen) 		//全部輸出與最長路徑整合 
{   
    if(T!=NULL)
    {   
		if(T->lchild==NULL && T->rchild==NULL)    //輸出棧中所有結點值
        {   
			printf("%c->",T->data);
	        for(int i=len-1;i>0;i--)
	        	printf("%c->",path[i]);
	        printf("%c\n",path[0]);
			if(len>maxlen) //通過比較求最長路徑
			{
				maxpath[len]=T->data;
				for(int i=len-1;i>=0;i--)
        		maxpath[i]=path[i];
        		maxlen=len+1;	
        	}
        	
        }
        else
        { 
			path[len++]=T->data;          //將當前節點放入路徑中   //路徑長度增1
        	zhenghe(T->lchild,path,len,maxpath,maxlen);
        	zhenghe(T->rchild,path,len,maxpath,maxlen);
        }
    }
}



void PreOrderPrintLeaves(BiTree T)			// 輸出葉子結點值
{
    if(T) 
    {
        if(T->lchild==NULL && T->rchild==NULL)
    		printf("%c ",T->data );
        PreOrderPrintLeaves (T->lchild);
        PreOrderPrintLeaves (T->rchild);
    }
}


int	main()
{
	BiTree	root; 
	printf("建立二叉樹\n");
	InitBiTree(root);
	CreateBiTree(root);
	printf("\n");
	
	printf("輸出二叉樹\n");//"ABD  EHJ  KL  M N   CF  G I  " 
	PreOrdershow(root);
	printf("\n\n");
/*
	printf("葉子結點逆序\n");
	TElemType path[MAXSIZE];
	LeavestoGra(root,path,0);
	printf("\n");
	
	printf("第一條最長逆路徑長度:");
	TElemType maxpath[MAXSIZE];int maxlen=0; 
	MaxPath(root,path,0,maxpath,maxlen);
	printf("%d\n",maxlen);
	printf("第一條最長逆路徑:");
	for(int j=maxlen;j>=0;j--)
        printf("%c ",maxpath[j]);
	printf("\n\n");
*/	
	//全部輸出與最長路徑整合 
	printf("葉子結點逆序\n");
	TElemType path[MAXSIZE];TElemType maxpath[MAXSIZE];int maxlen=0;  
	zhenghe(root,path,0,maxpath,maxlen);
	printf("\n");
	printf("第一條最長逆路徑長度:");
	printf("%d\n",maxlen);
	printf("第一條最長逆路徑:");
	for(int j=maxlen;j>=0;j--)
        printf("%c ",maxpath[j]);
	printf("\n\n");
	
	
	printf("釋放二叉樹\n");
	DestroyBiTree(root);			
}

搜索二叉樹應用——簡單字典實現

數據結構搜索二叉樹字典實現搜索二叉樹基本概念請看上篇博客這兩個問題都是典型的K（key）V（value）問題，我們用KV算法解決。判斷一個單詞是否拼寫正確：假設把所有單詞都按照搜索樹的性質插入到搜索二叉樹中，我們判斷一個單詞拼寫是否正確就是在樹中查找該單詞是否存在（查找key是否存在）。

二叉樹應用

#include<stdio.h> #include<stdlib.h> #define OK 1 #define ERROR 0 #define MAXSIZE 50 #define OVERFLOW -1 typedef int Status; t

[原始碼和文件分享]二叉樹應用

1 專案要求建立一棵二叉樹前序、中序、層次非遞迴遍歷該二叉樹判斷該二叉樹是否為二叉排序樹如果是二叉排序樹，進行結點的插入或刪除輸出結果 2 解題思路首先設計一個結構體，確定需要輸入的資料型別，再設計一個結構體，用來存放左右孩子的指標。輸入資料

資料結構之二叉樹應用（哈夫曼樹及哈夫曼編碼實現）（C++）

一、哈夫曼樹1.書上用的是靜態連結串列實現，本文中的哈夫曼樹用排序連結串列實現；2.實現了從字元頻率統計、構建權值集合、建立哈夫曼樹、生成哈夫曼編碼，最後對給定字串的編碼、解碼功能。3.使用到的 “SortedList.h”標頭檔案，在上篇博文：資料結構之排序單鏈表。

二叉樹應用_樹中兩個節點的最低公共祖先

題目：給定樹中的兩個節點，找出這兩個節點的最低公共祖先。情況1：當給定的樹為二叉搜尋樹時。分析：由於二叉搜尋樹是排序過的，位於左子樹的節點都小於根節點，位於右子樹的節點都大於根節點。如果要查詢的兩個節點比根節點大的話，則最低公共祖先在右子樹中；如果要查詢

LeetCode：二叉樹相關應用

div mage alt sed note col from ret 題目 LeetCode：二叉樹相關應用基礎知識 617.歸並兩個二叉樹題目 Given two binary trees and imagine that when you put one of th

二叉樹的應用

一、層序遍歷的應用：映象：還需要引入佇列，同上一篇部落格。 .h # pragma once # include<assert.h> # include<malloc.h> # include<stdio.h> # include<stdlib

二叉樹的應用詳解 - 資料結構

分享一下我老師大神的人工智慧教程！零基礎，通俗易懂！http://blog.csdn.net/jiangjunshow 也歡迎大家轉載本篇文章。分享知識，造福人民，實現我們中華民族偉大復興！

6.2.2-1 【指標與引用】在二叉樹建立的應用

0 引子　　本文旨在通過二叉樹的遞迴建立，分析指標與引用，函式形參與實參的具體實現。　　二叉樹的遍歷，通常是利用建立好的二叉連結串列的首地址，也即根節點地址。主函式先定義一指標，再通過二叉樹建立函式返回根結點地址，或者將定義的指標作為形參來實現修改。　　這就涉及函式形參與實參的呼叫機制。實參賦給形

【資料結構】二叉樹的應用

1、分別採用遞迴和非遞迴的方式編寫兩個函式，求一棵給定二叉樹中葉子節點的個數 2、返回一棵給定二叉樹在中序遍歷下的最後一個結點 3、假設二叉樹採用鏈式方式儲存，root為其根節點，p和q分別指向二叉樹中任意兩個結點，編寫一個函式，返回p和q最近的共同祖先。 #includ

【2018.10.10】簡單結構體二叉樹及其應用

簡單結構體二叉樹及其應用結構體二叉樹的建立可以使用遍歷或者遞迴，各有其特點，遍歷程式碼複雜但是便於理解與閱讀，遞迴理解更復雜，但是對應程式碼量要小很多 1.首先時畫出我們一會要建立的二叉樹。說是樹可我更覺得他像一個根型結構。這個二叉樹在前序遍歷裡的結構是：ABD##E##C#F

二叉樹採用二叉連結串列儲存，複製二叉樹的演算法（樹的應用）

二叉樹採用二叉連結串列儲存，試寫出複製一棵二叉樹的演算法。話不多說上程式碼： #include<stdio.h> #include<stdlib.h> typedef struct BiTnode { &

《資料結構與演算法設計》實驗報告書之二叉樹的基本操作實現及其應用

《資料結構與演算法設計》實驗報告書之二叉樹的基本操作實現及其應用實驗專案二叉樹的基本操作實現及其應用實驗目的 1．熟悉二叉樹結點的結構和對二叉樹的基本操作。 2．掌握對二叉樹每一種操作的具體實現。 3．學會利用遞迴方法編寫對二叉樹這種遞迴資料結構進行處理的演算法。 4.會用二叉

二叉樹層序遍歷與獲取二叉樹深度的應用

不同於中序、前序、和後續遍歷使用棧，層序遍歷使用的是佇列！程式碼如下： void level_order(tree_pointer ptr){ int front = rear = 0; tree_pointer queue[MAX_QUEUE_SIZE];

SDUTOJ1291資料結構上機測試4.1:二叉樹的遍歷與應用1

以SDUTOJ1291資料結構上機測試4.1:二叉樹的遍歷與應用1為例 https://acm.sdut.edu.cn/onlinejudge2/index.php/Home/Contest/contestproblem/cid/2711/pid/1291 思路：遞迴實現，化解子問

演算法--分奇偶行列印二叉樹--佇列的應用

頭條的一道面試題，層序列印二叉樹，奇數行時從左到右，偶數行時從右到左。如上所示，列印結果為： 1 3 2 4 5 6 7 10 9 8 1. 普通的層序列印二叉樹，一般採用一個佇列，根節點入佇列，然後一次遍歷佇列中的節

二叉樹的遍歷應用1

二叉樹的遍歷是指按某種順序訪問樹中的每個結點。由於二叉樹具有遞迴的性質，一棵非空的二叉樹可以看成是由根結點、左子樹和右子樹三部分組成，依次遍歷這3個部分的資訊，也就遍歷了二叉樹。完全二叉樹的順序儲存轉鏈式儲存一顆完全二叉樹存放在於一個一維陣列T【n】中，從T

二叉樹的遍歷應用2

遞迴演算法刪除二叉樹所有葉結點若二叉樹為空，返回NULL；若二叉樹只有一個結點，直接刪除；否則遞迴左右子樹。 void Del(BiTNode *&t) { if(t==NULL) return; if(t->lcild==NULL&am

資料結構知識整理 - 遍歷二叉樹的應用

主要內容建立二叉連結串列複製二叉樹計算二叉樹深度統計二叉樹的結點個數建立二叉連結串列在先序遍歷的遞迴演算法中，將輸出語句改為輸入語句即可。(可回顧“遞迴演算法”）需要注意的是，遞迴演算法會遍歷滿二叉樹中的每一個結點，

Leetcode 二叉樹的層次遍歷佇列的應用

給定一個二叉樹，返回其按層次遍歷的節點值。（即逐層地，從左到右訪問所有節點）。例如: 給定二叉樹: [3,9,20,null,null,15,7], 3 / \ 9 20 / \ 15 7 返回其層次遍歷結果： [ [

二叉樹應用

相關推薦