数据结构源码笔记（C语言）：二叉树遍历

最新推荐文章于 2023-07-28 17:12:38 发布

半个冯博士

最新推荐文章于 2023-07-28 17:12:38 发布

阅读量1.1k

点赞数 3

分类专栏：数据结构源码笔记（C语言）文章标签：数据结构算法指针二叉树 c语言

本文链接：https://blog.csdn.net/cauchy7203/article/details/107828261

版权

数据结构源码笔记（C语言）专栏收录该内容

40 篇文章 45 订阅

订阅专栏

//二叉树遍历 
#include<stdio.h>
#include<malloc.h>
#include<malloc.h>
#define MaxSize 100

typedef char ElemType;

typedef struct node
{
	ElemType data;
	struct node * lchild;
	struct node * rchild;
}BTNode;


void CreateBTNode(BTNode * &b,char *str) //由串str创建二叉树
{
	BTNode *St[MaxSize],*p=NULL;
	int top=-1,k,j=0;
	char ch;
	b=NULL;//创建的二叉树初始为空
	ch=str[j];
	while(ch!='\0')//str未扫描完毕，要继续循环扫描
	{
		switch(ch)
		{
		case '(':top++;St[top]=p;k=1;break;//左结点
		case ')':top--;break;  
		case ',':k=2;break;  //右结点
		default: p=(BTNode *)malloc(sizeof(BTNode));
			p->data=ch;p->lchild=p->rchild=NULL;
			if(b==NULL) //p指向二叉树的根结点
				b=p;
			else //已建立二叉树根结点
			{
				switch(k)
				{
				case 1:St[top]->lchild=p;break;
				case 2:St[top]->rchild=p;break;
				}
			}
	
		}
		j++;
		ch=str[j];
	}
}


 void DispBTNode(BTNode * b )  //以括号表示法输出二叉树
 {
	 if(b!=NULL)
	 {
		 printf("%c ",b->data);
		 if(b->lchild!=NULL||b->rchild!=NULL)
		 {
			 printf("(");
			 DispBTNode(b->lchild);
			 if(b->rchild!=NULL)printf(",");
			 DispBTNode(b->rchild);
			 printf(")");
		 }
	 }

 }



void PreOrder(BTNode *b)//先序 遍历的递归算法
{
	if(b!=NULL)
	{
		printf("%c ",b->data);//访问根节点
		PreOrder(b->lchild);//遍历访问左节点
		PreOrder(b->rchild);//遍历访问右结点
	}
}

void PreOrder1(BTNode *b)//先序遍历的非递归算法1
{
	BTNode * p;
	struct
	{
		BTNode * pt;
		int tag;
	} St[MaxSize];
	int top=-1;
	top++;
	St[top].pt=b;
	St[top].tag=1;
	while(top>-1)//栈不空时 循环
	{
		if(St[top].tag==1)//不能直接访问的情况
		{
			p=St[top].pt;
			top--;
			if(p!=NULL)
			{
				top++;//右孩子进栈
				St[top].pt=p->rchild;
				St[top].tag=1;
				top++;//左孩子进栈
				St[top].pt=p->lchild;
				St[top].tag=1;
				top++;//根节点进栈
				St[top].pt=p;
				St[top].tag=0;
			}
		}
		if(St[top].tag==0)//直接访问的情况
		{
			printf("%c ",St[top].pt->data);
			top--;
		}
	}
}

void PreOrder2(BTNode *b)//先序遍历非递归算法2
{
	BTNode * St[MaxSize],*p;
	int top=-1;
	if(b!=NULL)
	{
		top++;//根结点进栈
		St[top]=b;
		while(top>-1)//栈不为空时循环
		{
			p=St[top];//退栈并访问该结点
			top--;
			printf("%c ",p->data);
			if(p->rchild!=NULL)
			{
				top++;//右孩子进栈
				St[top]=p->rchild;
			}
			if(p->lchild!=NULL)
			{
				top++;//左孩子进栈
				St[top]=p->lchild;
			}
		}
		printf("\n");
	}
}

void InOrder(BTNode *b) //中序遍历的递归算法
{
	if(b!=NULL)
	{
		InOrder(b->lchild);//递归访问左子树
		printf("%c ",b->data);//归访问根结点
		InOrder(b->rchild);//递归访问右子数
	}
}

void InOrder1(BTNode *b)//中序遍历的非递归算法一
{
	BTNode *p;
	struct
	{
		BTNode *pt;
		int tag;
	}St[MaxSize];
	int top=-1;
	top++;
	St[top].pt=b;
	St[top].tag=1;
	while(top>-1)  //栈不空时循环
	{
		if(St[top].tag==1) //不能直接访问的情况
		{
			p=St[top].pt;
			top--;
			if(p!=NULL)
			{
				top++;   //右孩子进栈				
				St[top].pt=p->rchild;
				St[top].tag=1;
				top++;  //根结点进栈
				St[top].pt=p;
				St[top].tag=0;
				top++;  //左孩子进栈	
				St[top].pt=p->lchild;
				St[top].tag=1;
			}
		}
		if(St[top].tag==0)//直接访问情况	
		{
			printf("%c ",St[top].pt->data);
			top--;
		}
	}
}



void InOrder2(BTNode *b)//中序遍历的非递归算法二
{
	BTNode *St[MaxSize], *p;
	int top=-1;	
	if(b!=NULL)	
	{
		p=b;
		while(top>-1||p!=NULL)
		{
			while(p!=NULL)
			{
				top++;   				
				St[top]=p;
				p=p->lchild;
			}
			if(top>-1)
			{
				p=St[top];
				top--;
				printf("%c ",p->data);
				p=p->rchild;
			}
		}
			
		printf("\n");			
	}
}

void PostOrder(BTNode *b)  //后序遍历的递归算法
{
	if(b!=NULL)
	{
		PostOrder(b->lchild);//递归访问左子树
		PostOrder(b->rchild);//递归访问右子数
		printf("%c ",b->data);//访问根节点
	}
}


void PostOrder1(BTNode *b)  //后序遍历的非递归算法一
{
	BTNode  *p;
	struct
	{
		BTNode *pt;
		int tag;
	}St[MaxSize];

	int top=-1;
	top++;
	St[top].pt=b;
	St[top].tag=1;
	
	while(top>-1)//栈不为空时循环
	{
		if(St[top].tag==1)//不能直接访问的情况
		{
			p=St[top].pt;
			top--;
			if(p!=NULL)
			{
				top++;//根结点进栈
				St[top].pt=p;
				St[top].tag=0;
				top++;//右孩子进栈
				St[top].pt=p->rchild;
				St[top].tag=1;
				top++;//左孩子进栈
				St[top].pt=p->lchild;
				St[top].tag=1;
			}
		}
		if(St[top].tag==0)//直接访问的情况
		{
		    printf("%c ",St[top].pt->data);
			top--;
		}
	}
}



void PostOrder2(BTNode *b)//后序遍历的非递归算法二
{
	BTNode * St[MaxSize];
	BTNode *p;
	int flag,top=-1;//栈指针赋初值
	if(b!=NULL)
	{
		do
		{
			while(b!=NULL)//将T的左右左节点入栈
			{
				top++;
				St[top]=b;
				b=b->lchild;
			}
			p=NULL;//P指向当前结点的前一个已经访问的结点
			flag=1;//设置B的访问标记为已经访问过
			while(top!=-1&&flag)
			{
				b=St[top];//取出当前的栈顶元素
				if(b->rchild==p)//右子树不存在或已被访问，访问之
				{
					printf("%c ",b->data);//访问*b的结点
					top--;
					p=b;//p指向刚被访问的结点
				}
				else
				{
					b=b->rchild;//T指向右子树
					flag=0;//设置未被访问的标记
				}
			}
		}while(top!=-1);
		printf("\n");
	}
}

void TravLevel(BTNode *b)//层次遍历
{
	BTNode *Qu[MaxSize];//定义顺序循环队列
	int front,rear;//定义队首和队尾指针
	front=rear=0;//置队列为空队列
	if(b!=NULL)
		printf("%c ",b->data);
	rear++;//结点指针进入队列
	Qu[rear]=b;
	while(rear!=front)//队列不为空
	{
		front=(front+1)%MaxSize;//对头出队列
		b=Qu[front];//队头出队列
		if(b->lchild!=NULL)//输出左孩子，并进入队列
		{
			printf("%c ",b->lchild->data);
			rear=(rear+1)%MaxSize;
			Qu[rear]=b->lchild;
		}
		if(b->rchild!=NULL)//输出右孩子，并进入队列
		{
			printf("%c ",b->rchild->data);
			rear=(rear+1)%MaxSize;
			Qu[rear]=b->rchild;
		}
	}
	printf("\n");
}

int main()
{
	BTNode *b;
	CreateBTNode(b,"A(B(D,E(H(J,K(L,M(,N))))),C(F,G(,I)))");
	printf(" 二叉树B：");    	 DispBTNode(b);	 printf("\n\n");
	printf("层次遍历序列: ");	 TravLevel(b);	 printf("\n");
	 
	printf("先序遍历序列:\n");
	printf("   递归算法: ");      PreOrder(b);	 printf("\n");
	printf("非递归算法1: ");	 PreOrder1(b);	 printf("\n");
	printf("非递归算法2: ");	 PreOrder2(b);	 printf("\n");
	 
	printf("中序遍历序列:\n");
	printf("   递归算法: ");	  InOrder(b);	 printf("\n");
	printf("非递归算法1: ");	 InOrder1(b);	 printf("\n");
	printf("非递归算法2: ");	 InOrder2(b);	 printf("\n");

	printf("后序遍历序列:\n");
	printf("   递归算法: ");	 PostOrder(b);	 printf("\n");
	printf("非递归算法1: ");	 PostOrder1(b);	 printf("\n");
	printf("非递归算法2: ");	 PostOrder2(b);	 printf("\n");
	return 0;
}