二叉樹的基本操作（一）——二叉樹的遍歷

原文地址：
http://blog.csdn.net/fansongy/article/details/6798278/
http://blog.csdn.net/yelbosh/article/details/8043476

一、基本概念

每個結點最多有兩棵子樹，左子樹和右子樹，次序不可以顛倒。

性質：

1、非空二叉樹的第n層上至多有2^(n-1)個元素。
2、深度爲h的二叉樹至多有2^h-1個結點。

滿二叉樹（Full Binary Tree）：除最後一層無任何子節點外，每一層上的所有結點都有兩個子結點（最後一層上的無子結點的結點爲葉子結點）。也可以這樣理解，除葉子結點外的所有結點均有兩個子結點。節點數達到最大值。所有葉子結點必須在同一層上。
在滿二叉樹中若其深度爲h，則其所包含的結點數必爲2^h-1。

完全二叉樹（Complete Binary Tree）：　若設二叉樹的深度爲h，除第 h 層外，其它各層 (1～h-1) 的結點數都達到最大個數，第h層所有的結點都連續集中在最左邊，這就是完全二叉樹。
若一棵二叉樹至多隻有最下面的兩層上的結點的度數可以小於2，並且最下層上的結點都集中在該層最左邊的若干位置上，則此二叉樹成爲完全二叉樹。

滿二叉樹肯定是完全二叉樹
完全二叉樹不一定是滿二叉樹

二、存儲結構

順序存儲：將數據結構存在一塊固定的數組中。

    #define LENGTH 100  
    typedef char datatype;  
    typedef struct node{  
        datatype data;  
        int lchild,rchild;  
        int parent;  
    }Node;  

    Node tree[LENGTH];  
    int length;  
    int root;  

雖然在遍歷速度上有一定的優勢，但因所佔空間比較大，是非主流二叉樹。二叉樹通常以鏈式存儲。

typedef char datatype;  
typedef struct BinNode{  
    datatype data;  
    struct BinNode* lchild;  
    struct BinNode* rchild;  
}BinNode;  
typedef BinNode* bintree;          //bintree本身是個指向結點的指針

三、二叉樹的遍歷

遍歷即將樹的所有結點訪問且僅訪問一次。按照根節點位置的不同分爲前序遍歷，中序遍歷，後序遍歷。

前序遍歷（preorder tree walk）：根節點->左子樹->右子樹
中序遍歷（inorder tree walk）：左子樹->根節點->右子樹
後序遍歷（postorder tree walk）：左子樹->右子樹->根節點

例如：求下面樹的三種遍歷

前序遍歷：a b d e f g c
中序遍歷：d e b g f a c
後序遍歷：e d g f b c a

很明顯，前序序列的第一個元素和後序序列的最後一個元素一定是整個樹的根。

四、遍歷的實現

遞歸實現（以前序遍歷爲例，其他的只是輸出的位置稍有不同）

    void preorder(bintree t){  
        if(t){  
            printf("%c ",t->data);  
            preorder(t->lchild); 
            //printf("%c ",t->data);  中序遍歷的輸出位置 
            preorder(t->rchild);  
            //printf("%c ",t->data);  後序遍歷的輸出位置
        }  
    }  

非遞歸的實現

因爲當遍歷過根節點之後還要回來，所以必須將其存起來。考慮到後進先出的特點，選用棧存儲。數量確定，以順序棧存儲。

#define SIZE 100  
typedef struct seqstack{  
    bintree data[SIZE];  
    int tag[SIZE];   //爲後續遍歷準備的  
    int top;     //top爲數組的下標  
}seqstack;  

void push(seqstack *s,bintree t){  
    if(s->top == SIZE){  
        printf("the stack is full\n");  
    }else{  
        s->top++;  
        s->data[s->top]=t;  
    }  
}  

bintree pop(seqstack *s){  
    if(s->top == -1){  
        return NULL;  
    }else{  
        s->top--;  
        return s->data[s->top+1];  
    }  
}

1 前序遍歷

    void preorder_dev(bintree t){  
        seqstack s;  
        s.top = -1;     //因爲top在這裏表示了數組中的位置，所以空爲-1  
        if(!t){  
            printf("the tree is empty\n");  
        }else{  
            while(t || s.top != -1){  
                while(t){    //只要結點不爲空就應該入棧保存，與其左右結點無關      
                      printf("%c ",t->data);  
                      push(&s,t);  
                      t= t->lchild;  
                }  
                t=pop(&s);  
                t=t->rchild;  
            }  
        }  
    }  

2 中序遍歷

    void midorder(bintree t){  
        seqstack s;  
        s.top = -1;  
        if(!t){  
            printf("the tree is empty!\n");  
        }else{  
            while(t ||s.top != -1){  
                while(t){  
                    push(&s,t);  
                    t= t->lchild;  
                }  
                t=pop(&s);  
                printf("%c ",t->data);  
                t=t->rchild;  
            }  
        }  
    }  

3 後序遍歷
因爲後序遍歷最後還要要訪問根結點一次，所以要訪問根結點兩次。採取夾標誌位的方法解決這個問題。
這段代碼非常糾結，對自己有信心的朋友可以嘗試獨立寫一下。反正我是寫了很長時間。邏輯不難，我畫了一張邏輯圖：

    void postorder_dev(bintree t){  
        seqstack s;  
        s.top = -1;  
        if(!t){  
            printf("the tree is empty!\n");  
        }else{  
            while(t || s.top != -1){    //棧空了的同時t也爲空。  
                while(t){  
                    push(&s,t);  
                    s.tag[s.top] = 0;   //設置訪問標記，0爲第一次訪問，1爲第二次訪問  
                    t= t->lchild;  
                }  
                if(s.tag[s.top] == 0){  //第一次訪問時，轉向同層右結點  
                    t= s.data[s.top];   //左走到底時t是爲空的，必須有這步！  
                    s.tag[s.top]=1;       
                    t=t->rchild;  
                }else {  
                    while (s.tag[s.top] == 1){ //找到棧中下一個第一次訪問的結點，退出循環時並沒有pop所以爲其左子結點  
                        t = pop(&s);  
                        printf("%c ",t->data);  
                    }  
                    t = NULL; //必須將t置空。跳過向左走，直接向右走  
                }  
            }  
        }  
    }  

4 層次遍歷：即每一層從左向右輸出

元素需要儲存有先進先出的特性，所以選用隊列存儲。

隊列的定義：

    #define MAX 1000  

    typedef struct seqqueue{  
        bintree data[MAX];  
        int front;  
        int rear;  
    }seqqueue;  


    void enter(seqqueue *q,bintree t){  
        if(q->rear == MAX){  
            printf("the queue is full!\n");  
        }else{  
            q->data[q->rear] = t;  
            q->rear++;  
        }  
    }  

    bintree del(seqqueue *q){  
        if(q->front == q->rear){  
            return NULL;  
        }else{  
            q->front++;  
            return q->data[q->front-1];  
        }  
    } 

遍歷實現

    void level_tree(bintree t){  
        seqqueue q;  
        bintree temp;  
        q.front = q.rear = 0;  
        if(!t){  
            printf("the tree is empty\n");  
            return ;  
        }  
        enter(&q,t);  
        while(q.front != q.rear){  
            t=del(&q);  
            printf("%c ",t->data);  
            if(t->lchild){  
                enter(&q,t->lchild);  
            }  
            if(t->rchild){  
                enter(&q,t->rchild);  
            }  
        }  
    }  

5 二叉樹的查找

    bintree search_tree(bintree t,datatype x){  
        if(!t){  
            return NULL;  
        }  
        if(t->data == x){  
            return t;  
        }else{  
            if(!search_tree(t->lchild,x)){  
                return search_tree(t->rchild,x);  
            }  
            return t;  
        }  
    }  

6 統計節點個數

   int count_tree(bintree t){  
        if(t){  
            return (count_tree(t->lchild)+count_tree(t->rchild)+1);  
        }  
        return 0;  
    }  

7 比較兩個樹是否相同

    int is_equal(bintree t1,bintree t2){  
        if(!t1 && !t2){      //都爲空就相等  
            return 1;  
        }  
        if(t1 && t2 && t1->data == t2->data){      //有一個爲空或數據不同就不判斷了  
            if(is_equal(t1->lchild,t2->lchild))  
                if(is_equal(t1->rchild,t2->rchild)){  
                    return 1;  
                }  
        }  
        return 0;  
    }  

8 求二叉樹的深度

    int hight_tree(bintree t){  
        int h,left,right;  
        if(!t){  
            return 0;  
        }  
        left = hight_tree(t->lchild);  
        right = hight_tree(t->rchild);  
        h = (left>right?left:right)+1;  
        return h;  
    }