树及遍历

节点深度：从根到节点的路径长度，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 }

非递归就蛮麻烦了

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

 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 }

 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 }

这两个函数方法是一样的。都用到了栈。首先根节点先入栈，然后左节点、左节点的左节点啊一直入栈，直到没有左节点可入了。然后出栈，在节点出栈的时候它的左树已经走完了，同时右节点入栈。

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

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