数据结构-树与二叉树的递归与非递归遍历

一、二叉树的存储 （顺序和链式）

//二叉树的顺序存储 
#define Maxsize 100
struct  TreeNode{
	ElemType value;   //存放结点中的数据元素
	bool isEmpty;      //结点是否为空 
};
struct TreeNode t[Maxsize];
//初始化
void Init()
{
	for(int i=0;i<Maxsize;i++)
	{
		t[i].isEmpty=true;
	}
 } 
 
//二叉树的链式存储
struct  ElemType{
	int value;
};
typedef struct BiTNode{
	ElemType data;
	struct BiTNode *lchild,*rchild;
}BiTNode,*BiTree; 

//定义一棵空树 
BiTree root=NULL

//插入根结点
root=(BiTree)malloc(sizeof(BiTNode));
root->data={1};
root->lchild=NULL;
root->rchild=NULL; 

//插入新的结点
BiTNode *p=(BiTNode *)malloc(sizeof(BiTNode));
p->data={2};
p->lchild=NULL;
p->rchild=NNULL;
root->lchild=p; 

二、二叉树的遍历 

typedef struct BiTNode{
	ElemType data;
	struct BiTNode *lchild,*rchild;
}BiTNode,*BiTree;

2.1递归方法

//先序遍历
void PreOrder(BiTree T)
{
	if(T!=NULL)
	{
		visit(T);
		PreOrder(T->lchild);
		PreOrder(T->rchild);
	}
 } 
 
 //中序遍历
void InOrder(BiTree T)
{
	if(T!=NULL)
	{
		InOrder(T->lchild);
		visit(T);
		InOrder(T->rchild);
	}
 } 
 
 //后序遍历
 void PostOrder(BiTree T)
{
	if(T!=NULL)
	{
		PostOrder(T->lchild);
		PostOrder(T->rchild);
		visit(T);
	}
 }

2.2 非递归方法 

//先序遍历 
 void PreOrder(BiTree T)
 {
 	InitStack(S);
 	BiTree p=T;
 	while(p||!isEmpty(S))
 	{
 		if(p)
 		{
 			visit(p);
 			push(S,p);
 			p=p->lchild;
		}
 		else
 		{
 			pop(S,p);
 			p=p->rchild;
		}
	}
  } 

 //中序遍历 
 void InOrder(BiTree T)
 {
 	InitStack(S);
 	BiTree p=T;
 	while(p||!isEmpty(S))
 	{
 		if(p)
 		{
 			push(S,p);
 			p=p->lchild;
		}
 		else
 		{
 			pop(S,p);
 			visit(p); 
 			p=p->rchild;
		}
	}
  } 
  
//后序遍历
 void PostOrder(BiTree T)
 {
 	InitStack(S);
 	BiTree p=T;
	BiTree r=NULL;  //标记结点 
 	while(p||!isEmpty(S))
 	{
 		if(p)
 		{
 			push(S,p);
 			p=p->lchild;
		}
 		else
 		{
 			GetTop(S,p);       //若左孩子为空，先得到栈顶元素 
 			if(p->rchild&&p->rchild!=r)  //若栈顶元素的有孩子存在并且没被访问过 
 			{
 				p=p->rchild;
			}    
			else                   //否则的话，弹出栈顶元素并访问，同时标记该元素 
			{
				pop(S,p);
				visit(p->data);
				r=p;
				p=NULL;          //结点访问完，重置p指针 
			}
		}	
	}
  }  

后序遍历的一个基本应用：求树的深度

 //求树的深度
 int Depth(BiTree T)
 {
 	if(T==NULL)
 	{
		return 0;
	}
	else
	{
		int l=Depth(T->lchild);
		int r=Depth(T->rchild);
		return l>r? l+1:r+1;
	}
}  

2.3 层次遍历 

//二叉树的结点（链式存储） 
typedef struct BiTNode{
	char data;
	struct BiTNode *lchild,*rchild;
}BiTNode,*BiTree;

//链式队列结点 
typedef struct LinkNode{
	BiTNode *data;       //存放的是指针而不是结点 
	struct LinkNode *next;
}LinkNode; 

typedef struct{
	LinkNode *rear ,*front;	
}LinkQueue;

//层序遍历
void levelOrder(BiTree T)
{
	InitQueue(Q);
	BiTree p;
	EnQueue(Q,T);
	while(!IsEmpty(Q))
	{
		DeQueue(Q,p);   //队头结点出队 
		visit(p);       //访问队头结点 
		if(p->lchild!=NULL)   //左孩子不空，左孩子入队 
		EnQueue(p->lchild);
		if(p->rchild!=NULL)   //有孩子不空，右孩子入队 
		EnQueue(p->rchild);
	}
 }