出處：http://blog.csdn.net/sjf0115/article/details/8645991

樹形結構是一類重要的非線性資料結構，其中以樹和二叉樹最為常用。

二叉樹是每個結點最多有兩個子樹的有序樹。通常子樹的根被稱作“左子樹”（left subtree）和“右子樹”（right subtree）。二叉樹常被用作二叉查詢樹和二叉堆或是二叉排序樹。二叉樹的每個結點至多隻有二棵子樹(不存在度大於2的結點)，二叉樹的子樹有左右之分，次序不能顛倒。二叉樹的第i層至多有2的 i -1次方個結點；深度為k的二叉樹至多有2^(k) -1個結點；對任何一棵二叉樹T，如果其終端結點數(即葉子結點數)為n0，度為2的結點數為n2，則n0 = n2 + 1。

二叉樹的鏈式儲存結構是一類重要的資料結構，其形式定義如下：

1. //二叉樹結點
2. typedefstruct BiTNode{  
3.     //資料
4.     char data;  
5.     //左右孩子指標
6.     struct BiTNode *lchild,*rchild;  
7. }BiTNode,*BiTree;  

通過讀入一個字串，建立二叉樹的演算法如下：

1. //按先序序列建立二叉樹
2. int CreateBiTree(BiTree &T){  
3.     char data;  
4.     //按先序次序輸入二叉樹中結點的值（一個字元），‘#’表示空樹
5.     scanf("%c"
   ,&data);  
6.     if(data == '#'){  
7.         T = NULL;  
8.     }  
9.     else{  
10.         T = (BiTree)malloc(sizeof(BiTNode));  
11.         //生成根結點
12.         T->data = data;  
13.         //構造左子樹
14.         CreateBiTree(T->lchild);  
15.         //構造右子樹
16.         CreateBiTree(T->rchild);  
17.     }  
18.     return 0;  
19. }  

遍歷是對樹的一種最基本的運算，所謂遍歷二叉樹，就是按一定的規則和順序走遍二叉樹的所有結點，使每一個結點都被訪問一次，而且只被訪問一次。由於二叉樹是非線性結構，因此，樹的遍歷實質上是將二叉樹的各個結點轉換成為一個線性序列來表示。

遞迴演算法：

1. //輸出
2. void Visit(BiTree T){  
3.     if(T->data != '#'){  
4.         printf("%c ",T->data);  
5.     }  
6. }  
7. //先序遍歷
8. void PreOrder(BiTree T){  
9.     if(T != NULL){  
10.         //訪問根節點
11.         Visit(T);  
12.         //訪問左子結點
13.         PreOrder(T->lchild);  
14.         //訪問右子結點
15.         PreOrder(T->rchild);  
16.     }  
17. }  
18. //中序遍歷
19. void InOrder(BiTree T){  
20.     if(T != NULL){  
21.         //訪問左子結點
22.         InOrder(T->lchild);  
23.         //訪問根節點
24.         Visit(T);  
25.         //訪問右子結點
26.         InOrder(T->rchild);  
27.     }  
28. }  
29. //後序遍歷
30. void PostOrder(BiTree T){  
31.     if(T != NULL){  
32.         //訪問左子結點
33.         PostOrder(T->lchild);  
34.         //訪問右子結點
35.         PostOrder(T->rchild);  
36.         //訪問根節點
37.         Visit(T);  
38.     }  
39. }  

非遞迴演算法：

<1>先序遍歷：

【思路】：訪問T->data後，將T入棧，遍歷左子樹；遍歷完左子樹返回時，棧頂元素應為T，出棧，再先序遍歷T的右子樹。

1. /* 先序遍歷(非遞迴) 
2.    思路：訪問T->data後，將T入棧，遍歷左子樹；遍歷完左子樹返回時，棧頂元素應為T，出棧，再先序遍歷T的右子樹。 
3. */
4. void PreOrder2(BiTree T){  
5.     stack<BiTree> stack;  
6.     //p是遍歷指標
7.     BiTree p = T;  
8.     //棧不空或者p不空時迴圈
9.     while(p || !stack.empty()){  
10.         if(p != NULL){  
11.             //存入棧中
12.             stack.push(p);  
13.             //訪問根節點
14.             printf("%c ",p->data);  
15.             //遍歷左子樹
16.             p = p->lchild;  
17.         }  
18.         else{  
19.             //退棧
20.             p = stack.top();  
21.             stack.pop();  
22.             //訪問右子樹
23.             p = p->rchild;  
24.         }  
25.     }//while
26. }  

【思路】：T是要遍歷樹的根指標，中序遍歷要求在遍歷完左子樹後，訪問根，再遍歷右子樹。
         先將T入棧，遍歷左子樹；遍歷完左子樹返回時，棧頂元素應為T，出棧，訪問T->data，再中序遍歷T的右子樹。

1. void InOrder2(BiTree T){  
2.     stack<BiTree> stack;  
3.     //p是遍歷指標
4.     BiTree p = T;  
5.     //棧不空或者p不空時迴圈
6.     while(p || !stack.empty()){  
7.         if(p != NULL){  
8.             //存入棧中
9.             stack.push(p);  
10.             //遍歷左子樹
11.             p = p->lchild;  
12.         }  
13.         else{  
14.             //退棧，訪問根節點
15.             p = stack.top();  
16.             printf("%c ",p->data);  
17.             stack.pop();  
18.             //訪問右子樹
19.             p = p->rchild;  
20.         }  
21.     }//while
22. }  

【思路】：T是要遍歷樹的根指標，後序遍歷要求在遍歷完左右子樹後，再訪問根。需要判斷根結點的左右子樹是否均遍歷過。

1. //後序遍歷(非遞迴)
2. typedefstruct BiTNodePost{  
3.     BiTree biTree;  
4.     char tag;  
5. }BiTNodePost,*BiTreePost;  
6. void PostOrder2(BiTree T){  
7.     stack<BiTreePost> stack;  
8.     //p是遍歷指標
9.     BiTree p = T;  
10.     BiTreePost BT;  
11.     //棧不空或者p不空時迴圈
12.     while(p != NULL || !stack.empty()){  
13.         //遍歷左子樹
14.         while(p != NULL){  
15.             BT = (BiTreePost)malloc(sizeof(BiTNodePost));  
16.             BT->biTree = p;  
17.             //訪問過左子樹
18.             BT->tag = 'L';  
19.             stack.push(BT);  
20.             p = p->lchild;  
21.         }  
22.         //左右子樹訪問完畢訪問根節點
23.         while(!stack.empty() && (stack.top())->tag == 'R'){  
24.             BT = stack.top();  
25.             //退棧
26.             stack.pop();  
27.             BT->biTree;  
28.             printf("%c ",BT->biTree->data);  
29.         }  
30.         //遍歷右子樹
31.         if(!stack.empty()){  
32.             BT = stack.top();  
33.             //訪問過右子樹
34.             BT->tag = 'R';  
35.             p = BT->biTree;  
36.             p = p->rchild;  
37.         }  
38.     }//while
39. }  

<4>層次遍歷

【思路】：按從頂向下，從左至右的順序來逐層訪問每個節點，層次遍歷的過程中需要用佇列。

1. //層次遍歷
2. void LevelOrder(BiTree T){  
3.     BiTree p = T;  
4.     //佇列
5.     queue<BiTree> queue;  
6.     //根節點入隊
7.     queue.push(p);  
8.     //佇列不空迴圈
9.     while(!queue.empty()){  
10.         //對頭元素出隊
11.         p = queue.front();  
12.         //訪問p指向的結點
13.         printf("%c ",p->da