二叉樹是一種非常重要的資料結構，很多其他資料機構都是基於二叉樹的基礎演變過來的。二叉樹有前、中、後三種遍歷方式，因為樹的本身就是用遞迴定義的，因此採用遞迴的方法實現三種遍歷，不僅程式碼簡潔且容易理解，但其開銷也比較大，而若採用非遞迴方法實現三種遍歷，則要用棧來模擬實現（遞迴也是用棧實現的）。下面先簡要介紹三種遍歷方式的遞迴實現，再詳細介紹三種遍歷方式的非遞迴實現。

一、三種遍歷方式的遞迴實現（比較簡單，這裡不詳細講解）

1、先序遍歷——按照“根節點-左孩子-右孩子”的順序進行訪問。

void pre_traverse(BTree pTree)
{
	if(pTree)
	{
		printf("%c ",pTree->data);
		if(pTree->pLchild)
			pre_traverse(pTree->pLchild);
		if(pTree->pRchild)
			pre_traverse(pTree->pRchild);	
	}
}
 

    2、中序遍歷——按照“左孩子-根節點-右孩子”的順序進行訪問。

void in_traverse(BTree pTree)
{
	if(pTree)
	{
		if(pTree->pLchild)
			in_traverse(pTree->pLchild);
		printf("%c ",pTree->data);
		if(pTree->pRchild)
			in_traverse(pTree->pRchild);	
	}
}

    3、後序遍歷——按照“左孩子-右孩子-根節點”的順序進行訪問。

void beh_traverse(BTree pTree)
{
	if(pTree)
	{
		if(pTree->pLchild)
			beh_traverse(pTree->pLchild);
		if(pTree->pRchild)
			beh_traverse(pTree->pRchild);	
		printf("%c ",pTree->data);
}
 

    二、三種遍歷方式的非遞迴實現

    為了便於理解，這裡以下圖的二叉樹為例，分析二叉樹的三種遍歷方式的實現過程。

          1、前序遍歷的非遞迴實現 

根據先序遍歷的順序，先訪問根節點，再訪問左子樹，後訪問右子樹，而對於每個子樹來說，又按照同樣的訪問順序進行遍歷，上圖的先序遍歷順序為：ABDECF。非遞迴的實現思路如下：

對於任一節點P，

1）輸出節點P，然後將其入棧，再看P的左孩子是否為空；

2）若P的左孩子不為空，則置P的左孩子為當前節點，重複1）的操作；

3）若P的左孩子為空，則將棧頂節點出棧，但不輸出，並將出棧節點的右孩子置為當前節點，看其是否為空；

4）若不為空，則迴圈至1）操作；

5）如果為空，則繼續出棧，但不輸出，同時將出棧節點的右孩子置為當前節點，看其是否為空，重複4）和5）操作；

6）直到當前節點P為NULL並且棧空，遍歷結束。

   下面以上圖為例詳細分析其先序遍歷的非遞迴實現過程：

首先，從根節點A開始，根據操作1），輸出A，並將其入棧，由於A的左孩子不為空，根據操作2），將B置為當前節點，再根據操作1），將B輸出，並將其入棧，由於B的左孩子也不為空，根據操作2），將D置為當前節點，再根據操作1），輸出D，並將其入棧，此時輸出序列為ABD；

由於D的左孩子為空，根據操作3），將棧頂節點D出棧，但不輸出，並將其右孩子置為當前節點；

由於D的右孩子為空，根據操作5），繼續將棧頂節點B出棧，但不輸出，並將其右孩子置為當前節點；

由於B的右孩子E不為空，根據操作1），輸出E，並將其入棧，此時輸出序列為：ABDE；

由於E的左孩子為空，根據操作3），將棧頂節點E出棧，但不輸出，並將其右孩子置為當前節點；

由於E的右孩子為空，根據操作5），繼續將棧頂節點A出棧，但不輸出，並將其右孩子置為當前節點；

由於A的右孩子C不為空，根據操作1），輸出C，並將其入棧，此時輸出序列為：ABDEC；

由於A的左孩子F不為空，根據操作2），則將F置為當前節點，再根據操作1），輸出F，並將其入棧，此時輸出序列為：ABDECF；

由於F的左孩子為空，根據操作3），將棧頂節點F出棧，但不輸出，並將其右孩子置為當前節點；

由於F的右孩子為空，根據操作5），繼續將棧頂元素C出棧，但不輸出，並將其右孩子置為當前節點；

此時棧空，且C的右孩子為NULL，因此遍歷結束。

   根據以上思路，前序遍歷的非遞迴實現程式碼如下：

void pre_traverse(BTree pTree)
{
	PSTACK stack = create_stack();  //建立一個空棧
	BTree node_pop;                 //用來儲存出棧節點
	BTree pCur = pTree;             //定義用來指向當前訪問的節點的指標

	//直到當前節點pCur為NULL且棧空時，迴圈結束
	while(pCur || !is_empty(stack))
	{
		//從根節點開始，輸出當前節點，並將其入棧，
		//同時置其左孩子為當前節點，直至其沒有左孩子，及當前節點為NULL
		printf("%c ", pCur->data);
		push_stack(stack,pCur);
		pCur = pCur->pLchild;
		//如果當前節點pCur為NULL且棧不空，則將棧頂節點出棧，
		//同時置其右孩子為當前節點,迴圈判斷，直至pCur不為空
		while(!pCur && !is_empty(stack))
		{
			pCur = getTop(stack);
			pop_stack(stack,&node_pop);
			pCur = pCur->pRchild;			
		}
	}
}

根據中序遍歷的順序，先訪問左子樹，再訪問根節點，後訪問右子樹，而對於每個子樹來說，又按照同樣的訪問順序進行遍歷，上圖的中序遍歷順序為：DBEAFC。非遞迴的實現思路如下：

對於任一節點P，

1）若P的左孩子不為空，則將P入棧並將P的左孩子置為當前節點，然後再對當前節點進行相同的處理；

2）若P的左孩子為空，則輸出P節點，而後將P的右孩子置為當前節點，看其是否為空；

3）若不為空，則重複1）和2）的操作；

4）若為空，則執行出棧操作，輸出棧頂節點，並將出棧的節點的右孩子置為當前節點，看起是否為空，重複3）和4）的操作；

5）直到當前節點P為NULL並且棧為空，則遍歷結束。

   下面以上圖為例詳細分析其中序遍歷的非遞迴實現過程：

首先，從根節點A開始，A的左孩子不為空，根據操作1）將A入棧，接著將B置為當前節點，B的左孩子也不為空，根據操作1），將B也入棧，接著將D置為當前節點，由於D的左子樹為空，根據操作2），輸出D；

由於D的右孩子也為空，根據操作4），執行出棧操作，將棧頂結點B出棧，並將B置為當前節點，此時輸出序列為DB；

由於B的右孩子不為空，根據操作3），將其右孩子E置為當前節點，由於E的左孩子為空，根據操作1），輸出E，此時輸出序列為DBE；

由於E的右孩子為空，根據操作4），執行出棧操作，將棧頂節點A出棧，並將節點A置為當前節點，此時輸出序列為DBEA；

此時棧為空，但當前節點A的右孩子並不為NULL，繼續執行，由於A的右孩子不為空，根據操作3），將其右孩子C置為當前節點，由於C的左孩子不為空，根據操作1），將C入棧，將其左孩子F置為當前節點，由於F的左孩子為空，根據操作2），輸出F，此時輸出序列為：DBEAF；

由於F的右孩子也為空，根據操作4），執行出棧操作，將棧頂元素C出棧，並將其置為當前節點，此時的輸出序列為：DBEAFC；

由於C的右孩子為NULL，且此時棧空，根據操作5），遍歷結束。

    根據以上思路，中序遍歷的非遞迴實現程式碼如下：

void in_traverse(BTree pTree)
{
	PSTACK stack = create_stack();  //建立一個空棧
	BTree node_pop;                 //用來儲存出棧節點
	BTree pCur = pTree;             //定義指向當前訪問的節點的指標

	//直到當前節點pCur為NULL且棧空時，迴圈結束
	while(pCur || !is_empty(stack))
	{
		if(pCur->pLchild)
		{
			//如果pCur的左孩子不為空，則將其入棧，並置其左孩子為當前節點
			push_stack(stack,pCur);
			pCur = pCur->pLchild;
		}
		else
		{
			//如果pCur的左孩子為空，則輸出pCur節點，並將其右孩子設為當前節點，看其是否為空
			printf("%c ", pCur->data);
			pCur = pCur->pRchild;
			//如果為空，且棧不空，則將棧頂節點出棧，並輸出該節點，
			//同時將它的右孩子設為當前節點，繼續判斷，直到當前節點不為空
			while(!pCur && !is_empty(stack))
			{
				pCur = getTop(stack);
				printf("%c ",pCur->data);	
				pop_stack(stack,&node_pop);
				pCur = pCur->pRchild;
			}
		}
	}
}

   3、後序遍歷的非遞迴實現

根據後序遍歷的順序，先訪問左子樹，再訪問右子樹，後訪問根節點，而對於每個子樹來說，又按照同樣的訪問順序進行遍歷，上圖的後序遍歷順序為：DEBFCA。後序遍歷的非遞迴的實現相對來說要難一些，要保證根節點在左子樹和右子樹被訪問後才能訪問，思路如下：

對於任一節點P，

1）先將節點P入棧；

2）若P不存在左孩子和右孩子，或者P存在左孩子或右孩子，但左右孩子已經被輸出，則可以直接輸出節點P，並將其出棧，將出棧節點P標記為上一個輸出的節點，再將此時的棧頂結點設為當前節點；

3）若不滿足2）中的條件，則將P的右孩子和左孩子依次入棧，當前節點重新置為棧頂結點，之後重複操作2）；

4）直到棧空，遍歷結束。

   下面以上圖為例詳細分析其後序遍歷的非遞迴實現過程：

首先，設定兩個指標：Cur指標指向當前訪問的節點，它一直指向棧頂節點，每次出棧一個節點後，將其重新置為棧頂結點，Pre節點指向上一個訪問的節點；

Cur首先指向根節點A，Pre先設為NULL，由於A存在左孩子和右孩子，根據操作3），先將右孩子C入棧，再將左孩子B入棧，Cur改為指向棧頂結點B；

由於B的也有左孩子和右孩子，根據操作3），將E、D依次入棧，Cur改為指向棧頂結點D；

由於D沒有左孩子，也沒有右孩子，根據操作2），直接輸出D，並將其出棧，將Pre指向D，Cur指向棧頂結點E，此時輸出序列為：D；

由於E也沒有左右孩子，根據操作2），輸出E，並將其出棧，將Pre指向E，Cur指向棧頂結點B，此時輸出序列為：DE；

由於B的左右孩子已經被輸出，即滿足條件Pre==Cur->lchild或Pre==Cur->rchild，根據操作2），輸出B，並將其出棧，將Pre指向B，Cur指向棧頂結點C，此時輸出序列為：DEB；

由於C有左孩子，根據操作3），將其入棧，Cur指向棧頂節點F；

由於F沒有左右孩子，根據操作2），輸出F，並將其出棧，將Pre指向F，Cur指向棧頂結點C，此時輸出序列為：DEBF；

由於C的左孩子已經被輸出，即滿足Pre==Cur->lchild，根據操作2），輸出C，並將其出棧，將Pre指向C，Cur指向棧頂結點A，此時輸出序列為：DEBFC；

由於A的左右孩子已經被輸出，根據操作2），輸出A，並將其出棧，此時輸出序列為：DEBFCA；

此時棧空，遍歷結束。

void beh_traverse(BTree pTree)
{
	PSTACK stack = create_stack();  //建立一個空棧
	BTree node_pop;          //用來儲存出棧的節點
	BTree pCur;              //定義指標，指向當前節點
	BTree pPre = NULL;       //定義指標，指向上一各訪問的節點

	//先將樹的根節點入棧
	push_stack(stack,pTree);  
	//直到棧空時，結束迴圈
	while(!is_empty(stack))
	{
		pCur = getTop(stack);   //當前節點置為棧頂節點
		if((pCur->pLchild==NULL && pCur->pRchild==NULL) || 
			(pPre!=NULL && (pCur->pLchild==pPre || pCur->pRchild==pPre)))
		{
			//如果當前節點沒有左右孩子，或者有左孩子或有孩子，但已經被訪問輸出，
			//則直接輸出該節點，將其出棧，將其設為上一個訪問的節點
			printf("%c ", pCur->data);
			pop_stack(stack,&node_pop);
			pPre = pCur;
		}
		else
		{
			//如果不滿足上面兩種情況,則將其右孩子左孩子依次入棧
			if(pCur->pRchild != NULL)
				push_stack(stack,pCur->pRchild);
			if(pCur->pLchild != NULL)
				push_stack(stack,pCur->pLchild);
		}
	}
}

    以上遍歷演算法在VC上實現的輸出結果如下：