遍歷二叉樹的遞迴與非遞迴程式碼實現

　　遍歷二叉樹可以用遞迴的方法去實現，也可以用非遞迴的方法去實現。遞迴程式碼的好處是簡潔，直觀，最主要的還是遞迴的程式碼少，很快就可以寫完。但我們知道，遞迴的呼叫會用到一個專門的棧，這個棧的深度是有限的，如果遞迴函式呼叫的次數很多，超過棧限制的深度，那麼程式就會崩潰。這個時候就需要把遞迴的程式碼改為非遞迴了。因此，瞭解掌握遍歷二叉樹的非遞迴實現還是很有必要的。

　　下面會給出先序遍歷，中序遍歷，後序遍歷的遞迴與非遞迴程式碼，以及層次遍歷的程式碼。

　　首先，先給出二叉樹的節點定義：

struct BinTNode {
    int data;
    BinTNode *lchild, *rchild;
};

 

先序遍歷

　　先序遍歷，就是先訪問根節點，再訪問左子樹，最後再訪問右子樹。而要訪問左子樹，同樣是先訪問左子樹的根節點，再訪問左子樹的左子樹，最後再訪問左子樹的右子樹。訪問右子樹也是同樣的方法。所以，我們自然而然想到用遞迴的演算法。

　　為了方便表述，我們遍歷二叉樹所做的事情是把該節點的值輸出。

　　對於一個遞迴函式，我們不應該跳到遞迴裡面去，而是去理解遞迴函式的定義，也就是它的作用是什麼？遞迴結束後會返回什麼樣的結果？

　　我們把先序遍歷的遞迴函式定義為：傳入一個根節點，如果這個節點不為空，就輸出根節點的值，然後把左子樹的所有節點的值輸出，再把右子樹的所有節點的值輸出，這就是先序遍歷遞迴函式的作用。由於函式的返回值是void，所有遞迴結束後不會有返回結果。所以再按照先序遍歷的定義，我們可以把遞迴函式寫成下面這樣：

void preOrderTraversal(BinTNode *T) {
    if (T) {                            // 節點不為空才可以輸出值 
        cout << T -> data;              // 先輸出根節點的值 
        preOrderTraversal(T -> lchild); // 再把左子樹的根，也就是T -> lchild傳到我們的遞迴函式中，輸出左子樹所有節點的值 
        preOrderTraversal(T -> rchild); // 最後把右子樹的根，也就是T -> rchild傳到我們的遞迴函式中，輸出右子樹所有節點的值 
    }
}

　　瞭解了遞迴的程式碼後，接下來就是先序遍歷的非遞迴實現。

　　我們知道，當呼叫遞迴函式來遍歷二叉樹，每一個節點都會被訪問3次。

　　而先序遍歷就對應著當該節點被第1次訪問時就，輸出該節點的值。由於遞迴的本質是運用棧，因此我們也可以模擬一個棧來實現非遞迴。當遇到一個不為空的節點時，我們把這個節點壓入棧，這就對應於第1次訪問這個節點，所以在壓入棧後，輸出該節點的值。然後一直做T = T -> lchild這個動作，把節點對應的左子樹節點壓到棧，同時輸出節點的值。直到左子樹為空，這時就彈出棧頂元素，這個時候該節點被第2次訪問。把彈出節點的右子樹節點再壓入棧中。這個過程不斷重複，直到節點和棧都為空。這就實現了先序遍歷，先是根節點，再是左子樹，最後是右子樹。

　　先序遍歷的非遞迴程式碼如下：

void preOrderTraversal(BinTNode *T) {
    SNode *S = initStack();     // 申請一個棧
    while (T || !isEmpty(S)) {  // 迴圈的條件是根節點和棧不同時為空 
        if (T) {                // 如果根節點存在不為空 
            push(S, T);         // 把根節點壓入棧 
            cout << T -> data;  // 由於是第一次訪問該節點，所以輸出節點的值 
            T  = T -> lchild;   // 把左子樹的根節點賦值給T，進入下一次迴圈 
        }
        else {                  // 如果根節點為空 
            T = pop(S);         // 彈出棧頂元素，第二次訪問該節點  
            T = T -> rchild;    // 把右子樹的根節點賦值給T，進入下一次迴圈
        }
    }
}

　　還有另外一種先序遍歷的非遞迴程式碼，和上面的程式碼幾乎一樣：

void preOrderTraversal(BinTNode *T) {
    SNode *S = initStack();
    while (T || !isEmpty(S)) {
        while (T) {
            push(S, T);
            cout << T -> data;
            T = T -> lchild;
        }
        if (!isEmpty(S)) {
            T = pop(S);
            T = T -> rchild;
        }
    }
}

 

中序遍歷

　　中序遍歷，就是先訪問左子樹，再訪問根節點，最後再訪問右子樹。而要訪問左子樹，同樣是先訪問左子樹的左子樹，再訪問左子樹的根節點，最後再訪問左子樹的右子樹。訪問右子樹也是同樣的方法。所以，同樣可以用遞迴去實現。

　　我們把中序遍歷的遞迴函式定義為：傳入一個根節點，如果這個節點不為空，先把左子樹的所有節點的值輸出，再輸出根節點的值，最後把右子樹的所有節點的值輸出。其實，按照中序遍歷的定義，把先序遍歷的部分遞迴程式碼進行交換，就變成中序遍歷了：

void inOrderTraversal(BinTNode *T) {
    if (T) {                            // 節點不為空才可以輸出值
        inOrderTraversal(T -> lchild);  // 先把左子樹的根，也就是T -> lchild傳到我們的遞迴函式中，輸出左子樹所有節點的值
        cout << T -> data;              // 再輸出根節點的值
        inOrderTraversal(T -> rchild);  // 最後把右子樹的根，也就是T -> rchild傳到我們的遞迴函式中，輸出右子樹所有節點的值
    }
}

　　接下來是中序遍歷的非遞迴實現。按中序遍歷的定義，當節點被第2次訪問時，我們就輸出節點的值。所以中序遍歷和先序遍歷的非遞迴實現幾乎一樣，只不過是在節點被第2次訪問時才輸出該節點的值，所以我們只需要把輸出語句改放到該節點被第2次訪問之後就可以了，也就是改放到節點從棧頂被彈出之後。

void inOrderTraversal(BinTNode *T) {
    SNode *S = initStack();
    while (T || !isEmpty(S)) {
        if (T) {
            push(S, T);         // 把根節點壓入棧，第一次訪問該節點 
            T  = T -> lchild;
        }
        else {
            T = pop(S);         // 彈出棧頂元素，第二次訪問該節點 
            cout << T -> data;  // 由於是第二次訪問該節點，所以輸出節點的值 
            T = T -> rchild;
        }
    }
}

　　還有另外一種中序遍歷的非遞迴程式碼，和上面的程式碼幾乎一樣：

void inOrderTraversal(BinTNode *T) {
    SNode *S = initStack();
    while (T || !isEmpty(S)) {
        while (T) {
            push(S, T);
            T = T -> lchild;
        }
        if (!isEmpty(S)) {
            T = pop(S);
            cout << T -> data;
            T = T -> rchild;
        }
    }
}

 

後序遍歷

　　後序遍歷，就是先訪問左子樹，再訪問右子樹，最後再訪問根節點。而要訪問左子樹，同樣是先訪問左子樹的左子樹，再訪問左子樹的右子樹，最後再訪問左子樹的根節點。訪問右子樹也是同樣的方法。所以，同樣可以用遞迴去實現。

　　我們把後序遍歷的遞迴函式定義為：傳入一個根節點，如果這個節點不為空，先把左子樹的所有節點的值輸出，再把右子樹的所有節點的值輸出，最後再輸出根節點的值。和上面一樣，後序遍歷的遞迴函式只需要把部分遞迴程式碼進行交換：

void postOrderTraversal(BinTNode *T) {
    if (T) {                              // 節點不為空才可以輸出值 
        postOrderTraversal(T -> lchild);  // 先把左子樹的根，也就是T -> lchild傳到我們的遞迴函式中，輸出左子樹所有節點的值
        postOrderTraversal(T -> rchild);  // 再把右子樹的根，也就是T -> rchild傳到我們的遞迴函式中，輸出右子樹所有節點的值
        cout << T -> data;                // 最後輸出根節點的值
    }
}

　　至於後序遍歷的非遞迴實現，就沒有那麼容易了。如果我們嘗試在前面的先序遍歷和中序遍歷的非遞迴程式碼中，調換cout << T -> data; 這條語句的位置，我們會發現無論我們把它放在哪裡，都無法實現後續遍歷。這是由於在先序遍歷和中序遍歷的非遞迴程式碼中，每個節點最多能被訪問2次，也就是在壓入和彈出時被訪問。而後序遍歷要求是在節點被第3次訪問時才輸出節點的值。所以很明顯，之前的非遞迴函式並不能夠實現後序遍歷。所以我們只能夠用其他的方法來實現非遞迴的後序遍歷。

　　下面給出兩種不同的後序遍歷的非遞迴程式碼實現：

　　1. 在節點中加入一個標誌域。

struct BinTNode {
    int data;
    BinTNode *lchild, *rchild;
    bool isFirst;    // 第一次訪問節點時賦值為true；第二次訪問時，也就是從棧頂彈出時賦值為false，再壓入棧中；當節點再彈出時已是第三次訪問該節點了 
};

　　標誌域的作用就是，當節點是第一次被彈出時，如果節點的標誌域為true，那麼我們再次把它壓入棧裡面，同時把標誌域改為false，這樣該節點就可以再彈出一次。當再次彈出該節點時，又因為此時節點的標誌域為false，不會再被壓入，從而該節點就可以實現被訪問3次了。

　　這樣子我們就可以對一個節點訪問3次，在第3次訪問時輸出該節點的值，從而就可以實現後序遍歷了：

void postOrderTraversal(BinTNode *T) {
    SNode *S = initStack();
    while (T || !isEmpty(S)) {
        if (T) {
            push(S, T);                  // 把根節點壓入棧，第一次訪問該節點
            T -> isFirst = true;         // 標誌域賦值為true 
            T = T -> lchild;
        }
        else {
            T = pop(S);
            if (T -> isFirst) {         // 如果節點的標誌域為true 
                push(S, T);             // 我們繼續把它壓入棧中，同時該節點被第二次訪問 
                T -> isFirst = false;   // 同時再為該節點的標誌域賦值為false，下一次再彈出該節點時就不再壓入棧中 
                T = T -> rchild;
            }
            else {                      // 如果節點的標誌域為false 
                cout << T -> data;      // 此時是第三次訪問該節點，可以輸出該節點的值了 
                T = NULL;               // 該節點的左右孩子都訪問完了，我們把NULL賦值給T，在下一次的迴圈，去接收棧頂元素 
            }
        }
    }
}

　　2. 藉助輔助指標last，last指向最近訪問過的節點，也就是指向從棧頂彈出後，沒有再被壓入棧的那個節點。

　　用棧來儲存節點時，按照先序遍歷和中序遍歷的非遞迴程式碼，節點只能被訪問兩次。而後序遍歷的順序是先訪問左子樹，再訪問右子樹，最後才訪問根節點。所以我們應該分清除當一個根節點從棧頂彈出時，上一次從棧頂彈出的節點到底是它的左子樹的根節點，還從它右子樹的根節點。所以，可以用輔助指標last，來指向最近訪問過的節點，看它是不是該節點右子樹的根節點。如果是，就說明該節點的左右子樹都已經訪問完了，可以輸出該節點的值了。

　　舉個簡單的例子：

void postOrderTraversal(BinTNode *T) {
    SNode *S = initStack();
    BinTNode *last = NULL;                                // last指向剛訪問完的節點    
    while (T || !isEmpty(S)) {
        if (T) {
            push(S, T);
            T = T -> left;
        }
        else {
            T = pop(S);
            if (T -> rchild && T -> rchild != last) {    // 如果該根節點的右孩子不為空，並且該根節點的右孩子不是剛訪問的那個節點（這意味著該根節點的右子樹還沒有訪問，是從左子樹返回到該根節點的）
                push(S, T);                              // 再把該根節點壓入，這樣子當該節點再次被彈出時，已是被第三次訪問了 
                T = T -> rchild;                         // 向下一次迴圈傳入該根節點右子樹的根節點 
            }
            else {                                       // 根節點的右孩子為空或者該根節點的右孩子就是剛訪問的那個節點（這意味著該根節點的右子樹已經被訪問了，是從右子樹返回到該根節點的）
                cout << T -> data;                       // 第三次訪問該節點，所以輸出節點的值
                last = T;                                // 因為該根節點被訪問了，所以last指向該節點 
                T = NULL;                                // 由於該節點的左右孩子都訪問完了，我們把NULL賦值給T，在下一次的迴圈，去接收棧頂元素 
            }
        }
    }
}

 

 層次遍歷

　　最後一個是層次遍歷，它不是用棧來實現的，而是用佇列來實現的。類似於圖的廣度優先搜尋（BFS）。

　　因此，如果要用遞迴來實現層次遍歷，這會是很困難的事情。這裡就不討論了。

　　下面給出層次遍歷的程式碼：

void levelOrderTraversal(BinTNode *T) {
    if (T == NULL) return;
    
    QNode *Q = initQueue();
    push(Q, T);
    while (!isEmpty(Q)) {
        T = pop(S);
        cout << T -> data;
        
        if (T -> lchild) push(Q, T -> lchild);
        if (T -> rchild) push(Q, T -> rchild);
    }
}

 

參考資料

　　《資料結構：C語言版-第二版》

　　浙江大學——資料結構：https://www.icourse163.org/course/ZJU-93001?tid=1461682474

　　二叉樹後序遍歷的非遞迴實現：https://blog.csdn.net/u013161323/article/details/53925313