二叉树的遍历(图示+详细代码)递归与非递归解法

先序遍历（NLR）：根结点 - 左子树 - 右子树

中序遍历（LNR）：左子树 - 根结点 - 右子树

后序遍历（LRN）：左子树 - 右子树 - 根结点

输入：ABD^^EG^^^C^F^^

△前序遍历 A B D E G C F
△中序遍历 D B G E A C F
△后序遍历 D G E B F C A
△层次遍历 A B C D E F G

 

递归实现：

（一）数组

//前序遍历二叉树
void PreOrderTraverse_Sq(SqBiTree T,int i){
	if(T[i]!='\0'){
		printf("%c ",T[i]);
		PreOrderTraverse_Sq(T,2*i+1);
		PreOrderTraverse_Sq(T,2*i+2);
	} 
}
//中序遍历二叉树
void InOrderTraverse_Sq(SqBiTree T,int i){
	if(T[i]!='\0'){
		InOrderTraverse_Sq(T,2*i+1);
		printf("%c ",T[i]);
		InOrderTraverse_Sq(T,2*i+2);
	} 
} 
//后序遍历二叉树
void PostOrderTraverse_Sq(SqBiTree T,int i){
	if(T[i]!='\0'){
		PostOrderTraverse_Sq(T,2*i+1);
		PostOrderTraverse_Sq(T,2*i+2);
		printf("%c ",T[i]);
	} 
}

（二）二叉链表

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

void PreOrder(BiTree T){
	if(T!=NULL){
		printf("%c ",T->data);
		PreOrder(T->lchild);
		PreOrder(T->rchild);
	}
}
void InOrder(BiTree T){
	if(T!=NULL){
		InOrder(T->lchild);
		printf("%c ",T->data);
		InOrder(T->rchild);
	}
}
void PostOrder(BiTree T){
	if(T!=NULL){
		PostOrder(T->lchild);
		PostOrder(T->rchild);
		printf("%c ",T->data);
	}
}

非递归实现：

1.先序非递归遍历

对于任一结点，其可看做是根结点，因此可以直接访问，访问完之后，若其左孩子不为空，按相同规则访问它的左子树；当访问其左子树时，再访问它的右子树。

对于任一结点P：

     1)访问结点P，并将结点P入栈;

     2)判断结点P的左孩子是否为空，若为空，则取栈顶结点并进行出栈操作，并将栈顶结点的右孩子置为当前的结点P;

        若不为空，则将P的左孩子置为当前的结点P;

     3)直到P为NULL并且栈为空，则遍历结束。

void PreOrder(BiTree T){
	stack<BiTree> S;
	BiTree p=T;//p是遍历指针
	while(p||!S.empty()){//栈不空或p不空时循环 
		while(p){//根指针进栈，遍历左子树 
			printf("%c ",p->data);
			S.push(p);
			p=p->lchild;   
		}
		if(!S.empty())
		{
			p=S.top();
			S.pop();
			p=p->rchild;//遍历右子树 
		}
	} 
}

2.中序非递归遍历

• 遇到一个结点，就把它压栈，并去遍历它的左子树；
• 当左子树遍历结束后，从栈顶弹出这个结点并访问它；
• 然后按其右指针再去中序遍历该结点的右子树。

和先序遍历类似，只不过访问结点语句的位置不同（printf("%c ",p->data);）

void InOrder(BiTree T){
	stack<BiTree> S;
	BiTree p=T;//p是遍历指针
	while(p||!S.empty()){//栈不空或p不空时循环 
		if(p){//根指针进栈，遍历左子树 
			S.push(p);//遇到非空二叉树先向左走
			p=p->lchild; 
		} else{
			p=S.top();
			S.pop();//退栈 
			printf("%c ",p->data);//访问根节点 
			p=p->rchild;//遍历右子树 
		}
	} 
}

3.后序非递归遍历

后序遍历要保证根结点在左孩子和右孩子访问之后才能访问。

因此对于任一结点P，先将其入栈。如果P不存在左孩子和右孩子，则可以直接访问它；或者P存在左孩子或者右孩子，但是其左孩子和右孩子都已被访问过了，则同样可以直接访问该结点。若非上述两种情况，则将P的右孩子和左孩子依次入栈(注意先右后左)，这样就保证了每次取栈顶元素的时候，左孩子在右孩子前面被访问，左孩子和右孩子都在根结点前面被访问。

void PostOrder(BiTree T){
	stack<BiTree> S;
	BiTree cur;//当前结点 
	BiTree pre=NULL;//前一次访问的结点 
	S.push(T);//将根节点入栈 
	while(!S.empty()){ 
		cur=S.top();
		//如果当前结点没有孩子结点或者孩子节点都已被访问过		
		if((cur->lchild==NULL&&cur->rchild==NULL)||
		(pre!=NULL&&(pre==cur->lchild||pre==cur->rchild)))
		{
			printf("%c ",cur->data);
			S.pop();
			//pre标记已经访问过的结点 
			pre=cur;
		}
		else{
			if(cur->rchild!=NULL){
				S.push(cur->rchild);
			} 
			if(cur->lchild!=NULL){
				S.push(cur->lchild);
			}		
		}
	} 
}

4.层次遍历

先将根节点入队，然后

• 从队列中取出一个元素；
• 访问该元素所指结点；
• 若该元素所指结点的左、右孩子结点非空， 则将其左、右孩子的指针顺序入队。

void LevelOrder(BiTree T){
	queue<BiTree> Q;
	BiTree p;
	Q.push(T);//将根节点入队 
	while(!Q.empty()){//队不空时循环 
		p=Q.front();
		Q.pop();
		printf("%c ",p->data);//访问当前p所指向结点 
		if(p->lchild!=NULL){
			Q.push(p->lchild);//左子树不空，则左子树入队列 
		}
		if(p->rchild!=NULL){
			Q.push(p->rchild);//右子树不空，则右子树入队列
		}
	} 
}