④树及遍历

注：此文多来自于海子博客：http://www.cnblogs.com/dolphin0520/archive/2011/08/25/2153720.html

节点深度：从根到节点的路径长度，d（root）=0

节点高度：从节点到树叶的最长路径的长，h(leaf)=0

树高为根高，树的深度=树的高度

 

树的遍历：

递归的前、中、后序还是蛮简单的：

 1 //树的遍历
 2 void preorder_recursive(PtrToBiNode T){   //二叉树递归先序遍历 
 3     if (T){                 //这句不要忘记 
 4         printf("%d ", T->Element);
 5         preorder_recursive(T->left);
 6         preorder_recursive(T->right);
 7     }
 8 }
 9 
10 void inorder_recursive(PtrToBiNode T){   //二叉树递归中序遍历 
11     if (T){
12         inorder_recursive(T->left);
13         printf("%d ", T->Element);
14         inorder_recursive(T->right);
15     }
16 }
17 
18 void lastorder_recursive(PtrToBiNode T){//二叉树递归后序遍历 
19     if (T){
20         lastorder_recursive(T->left);
21         lastorder_recursive(T->right);
22         printf("%d ", T->Element);
23     }
24 }
View Code

 

非递归就蛮麻烦了

非递归前序和中序直接上代码：

 1 void preorder_nonrecursive1(PtrToBiNode T){   //二叉树非递归先序遍历1  左节点一个个入栈，再依次弹出，入右节点
 2     PtrToBiNode stack[MAXSIZE];
 3     PtrToBiNode T1;
 4     int top = -1;
 5     while (T || top != -1){
 6 
 7         while (T){
 8             stack[++top] = T;
 9             printf("%d ", T->Element);
10             T = T->left;
11 
12         }
13         if (top != -1){
14             T = stack[top--];
15             T = T->right;
16 
17 
18         }
19     }
20     
21 }
View Code
 1 void inorder_nonrecursive(PtrToBiNode T){   //二叉树非递归中序遍历
 2     PtrToBiNode stack[MAXSIZE];
 3     PtrToBiNode T1;
 4     int top = -1;
 5     while (T || top != -1){
 6 
 7         while (T){
 8             stack[++top] = T;
 9             T = T->left;
10 
11         }
12         if (top != -1){
13             T = stack[top--];
14             printf("%d ", T->Element);
15             T = T->right;
16 
17 
18         }
19     }
20 
21 
22 
23 }
View Code

 

这两个函数方法是一样的。都用到了栈。

首先根节点先入栈，然后它左节点、左节点的左节点啊一直入栈，直到没有左节点可入了。然后出栈，在节点出栈的时候它的左树已经走完了，之后它的右节点入栈。

 

非递归后序就比较麻烦了：

首先也是某个节点入栈，然后它的左节点、左节点的左节点啊一直入栈，直到没有左节点可入了。这时候因为右树还没走过，栈顶那个节点是第一次出现，所以先不出栈，让它的右节点入栈，等右树走完后，栈顶又出现了那个节点，这时候就可以出栈输出了。

 1 void lastorder_nonrecursive1(PtrToBiNode Tree){   //二叉树非递归后序遍历1
 2     BTree stack[MAXSIZE];
 3     int top = -1;
 4     Position P = Tree;
 5     while (P != NULL || top != -1){
 6     
 7         while (P != NULL){
 8             BTree T = (BTree)malloc(sizeof(struct BinTree));
 9             T->isFirst = true;
10             T->Person = P;
11             stack[++top] = T;
12             P = P->left;
13 
14         }
15         if (top != -1){
16             if (stack[top]->isFirst == false){
17                 printf("%d ", stack[top--]->Person->Element);
18                 P = NULL;
19             }
20             else{
21                 stack[top]->isFirst = false;
22                 P = stack[top]->Person->right;
23             }
24         }
25     }
26 }
View Code
 1 void lastorder_nonrecursive2(PtrToBiNode T){   //二叉树非递归后序遍历2
 2     Position stack[MAXSIZE];
 3     Position pre=NULL;
 4     int top = -1; stack[++top] = T;
 5     while (top != -1){
 6         T = stack[top];
 7         if ((T->left == NULL&&T->right == NULL) || (pre!=NULL&&(pre == T->left || pre == T->right))){
 8             pre = T;
 9             printf("%d", T->Element);
10             top--;
11         }
12         else{
13             if (T->right)
14                 stack[++top] = T->right;
15             if (T->left)
16                 stack[++top] = T->left;
17         }
18     }
19 }
View Code

 

And还有层次遍历：

层次遍历要用到队列，就是先根节点进去，然后出来，再它的两个儿子进去，然后一个儿子出来，这个儿子的两个儿子再进去。。。。。。就可以啦～

 

posted @ 2015-02-20 16:50  stezqy  阅读(131)  评论(0)    收藏  举报