2. 程式人生 > >二叉樹的三種遍歷方式（遞迴、非遞迴和Morris遍歷）

二叉樹的三種遍歷方式（遞迴、非遞迴和Morris遍歷）

阿新 • • 發佈：2019-01-28

二叉樹遍歷是二叉樹的最基本的操作，其實現方式主要有三種：

  1. 遞迴遍歷
  2. 非遞迴遍歷
  3. Morris遍歷

遞迴遍歷的實現非常容易，非遞迴實現需要用到棧。而Morris演算法可能很多人都不太熟悉，其強大之處在於只需要使用O(1)的空間就能實現對二叉樹O(n)時間的遍歷。

二叉樹結點的定義

每個二叉樹結點包括一個值以及左孩子和右孩子結點，其定義如下：

class TreeNode {
    public:
        int val;
        TreeNode *left, *right;
        TreeNode(int val) {
            this
 
->val = val;
            this->left = this->right = NULL;
        }   
};

二叉樹的遍歷

二叉樹的遍歷，就是按照某條搜尋路徑訪問樹中的每一個結點，使得每個結點均被訪問一次，而且僅被訪問一次。常見的遍歷次序有：

  1. 先序遍歷：先訪問根結點，再訪問左子樹，最後訪問右子樹
  2. 中序遍歷：先訪問左子樹，再訪問根結點，最後訪問右子樹
  3. 後序遍歷：先訪問左子樹，再訪問右子樹，最後訪問根結點

下面介紹，二叉樹3種遍歷方式的實現。

遞迴遍歷

遞迴實現非常簡單，按照遍歷的次序，對當前結點分別呼叫左子樹和右子樹即可。

前序遍歷

void preOrder(TreeNode *root) {
    if(root == NULL)
        return;
    cout << root->val << endl;
    preOrder(root->left);
    preOrder(root->right);
}

中序遍歷

void inOrder(TreeNode *root) {
    if(root == NULL)
        return;
    inOrder(root->left);
    cout <<
 
 root->val << endl;
    inOrder(root->right);
}

後序遍歷

void postOrder(TreeNode *root) {
    if(root == NULL)
        return;
    postOrder(root->left);
    postOrder(root->right);
    cout << root->val << endl;
}

複雜度分析

二叉樹遍歷的遞迴實現，每個結點只需遍歷一次，故時間複雜度為O(n)。而使用了遞迴，最差情況下遞迴呼叫的深度為O(n)，所以空間複雜度為O(n)。

非遞迴遍歷

二叉樹遍歷的非遞迴實現，可以藉助棧。

前序遍歷

  1. 將根結點入棧；
  2. 每次從棧頂彈出一個結點，訪問該結點；
  3. 把當前結點的右孩子入棧；
  4. 把當前結點的左孩子入棧。

按照以上順序入棧，這樣出棧順序就與先序遍歷一樣：先根結點，再左子樹，最後右子樹。

void preOrder2(TreeNode *root) {
    if(root == NULL)
        return;

    stack<TreeNode *> stk;
    stk.push(root);                                                                                                                                                                            
    while(!stk.empty()) {
        TreeNode *pNode = stk.top();
        stk.pop();
        cout << pNode->val << endl;
        if(pNode->right != NULL)
            stk.push(pNode->right);
        if(pNode->left != NULL)
            stk.push(pNode->left);
    }
}

中序遍歷

  1. 初始化一個二叉樹結點pNode指向根結點；
  2. 若pNode非空，那麼就把pNode入棧，並把pNode變為其左孩子；（直到最左邊的結點）
  3. 若pNode為空，彈出棧頂的結點，並訪問該結點，將pNode指向其右孩子（訪問最左邊的結點，並遍歷其右子樹）
void inOrder2(TreeNode *root) {
    if(root == NULL)
        return;

    stack<TreeNode *> stk;
    TreeNode *pNode = root;
    while(pNode != NULL || !stk.empty()) {
        if(pNode != NULL) {
            stk.push(pNode);
            pNode = pNode->left;
        }
        else {
            pNode = stk.top();
            stk.pop();
            cout << pNode->val << endl;
            pNode = pNode->right;
        }
    }
}

後序遍歷

  1. 設定兩個棧stk, stk2；
  2. 將根結點壓入第一個棧stk；
  3. 彈出stk棧頂的結點，並把該結點壓入第二個棧stk2；
  4. 將當前結點的左孩子和右孩子先後分別入棧stk；
  5. 當所有元素都壓入stk2後，依次彈出stk2的棧頂結點，並訪問之。

第一個棧的入棧順序是：根結點，左孩子和右孩子；於是，壓入第二個棧的順序是：根結點，右孩子和左孩子。因此，彈出的順序就是：左孩子，右孩子和根結點。

void postOrder2(TreeNode *root) {
    if(root == NULL)
        return;

    stack<TreeNode *> stk, stk2;
    stk.push(root);
    while(!stk.empty()) {
        TreeNode *pNode = stk.top();
        stk.pop();
        stk2.push(pNode);
        if(pNode->left != NULL)
            stk.push(pNode->left);
        if(pNode->right != NULL)
            stk.push(pNode->right);
    }
    while(!stk2.empty()) {
        cout << stk2.top()->val << endl;
        stk2.pop();
    }
}

另外，二叉樹的後序遍歷的非遞迴實現，也可以只使用一個棧來實現。

void postOrder2(TreeNode *root) {
    if(root == NULL)
        return;

    stack<TreeNode *> stk;
    stk.push(root);
    TreeNode *prev = NULL;
    while(!stk.empty()) {
        TreeNode *pNode = stk.top();
        if(!prev || prev->left == pNode || prev->right == pNode) {  // traverse down
            if(pNode->left)
                stk.push(pNode->left);
            else if(pNode->right)
                stk.push(pNode->right);

         /* else {
                cout << pNode->val << endl;
                stk.pop();
            }
        */

        }
        else if(pNode->left == prev) {  // traverse up from left
            if(pNode->right)
                stk.push(pNode->right);
        }

    /* else if(pNode->right == prev) { // traverse up from right
                cout << pNode->val << endl;
                stk.pop();
        }
    */

        else {
            cout << pNode->val << endl;
            stk.pop();
        }
        prev = pNode;
    }
}

複雜度分析

二叉樹遍歷的非遞迴實現，每個結點只需遍歷一次，故時間複雜度為O(n)。而使用了棧，空間複雜度為二叉樹的高度，故空間複雜度為O(n)。

Morris遍歷

Morris遍歷演算法最神奇的地方就是，只需要常數的空間即可在O(n)時間內完成二叉樹的遍歷。O(1)空間進行遍歷困難之處在於在遍歷的子結點的時候如何重新返回其父節點？在Morris遍歷演算法中，通過修改葉子結點的左右空指標來指向其前驅或者後繼結點來實現的。

中序遍歷

  1. 如果當前結點pNode的左孩子為空，那麼輸出該結點，並把該結點的右孩子作為當前結點；
  2. 如果當前結點pNode的左孩子非空，那麼就找出該結點在中序遍歷中的前驅結點pPre
    • 當第一次訪問該前驅結點pPre時，其右孩子必定為空，那麼就將其右孩子設定為當前結點，以便根據這個指標返回到當前結點pNode中，並將當前結點pNode設定為其左孩子；
    • 當該前驅結點pPre的右孩子為當前結點，那麼就輸出當前結點，並把前驅結點的右孩子設定為空（恢復樹的結構），將當前結點更新為當前結點的右孩子
  3. 重複以上兩步，直到當前結點為空。
void inOrder3(TreeNode *root) {
    if(root == NULL)
        return;

    TreeNode *pNode = root;
    while(pNode != NULL) {
        if(pNode->left == NULL) {
            cout << pNode->val << endl;
            pNode = pNode->right;
        }
        else {
            TreeNode *pPre = pNode->left;
            while(pPre->right != NULL && pPre->right != pNode) {
                pPre = pPre->right;
            }

            if(pPre->right == NULL) {
                pPre->right = pNode;
                pNode = pNode->left;
            }
            else {
                pPre->right = NULL;
                cout << pNode->val << endl;
                pNode = pNode->right;
            }
        }
    }
}

因為只使用了兩個輔助指標，所以空間複雜度為O(1)。對於時間複雜度，每次遍歷都需要找到其前驅的結點，而尋找前驅結點與樹的高度相關，那麼直覺上總的時間複雜度為O(nlogn)。其實，並不是每個結點都需要尋找其前驅結點，只有左子樹非空的結點才需要尋找其前驅，所有結點尋找前驅走過的路的總和至多為一棵樹的結點個數。因此，整個過程每條邊最多走兩次，一次使定位到該結點，另一次是尋找某個結點的前驅，所以時間複雜度為O(n)。

如以下一棵二叉樹。首先，訪問的是根結點F，其左孩子非空，所以需要先找到它的前驅結點（尋找路徑為B->D->E），將E的右指標指向F，然後當前結點為B。依然需要找到B的前驅結點A，將A的右指標指向B，並將當前結點設定為A。下一步，輸出A，並把當前結點設定為A的右孩子B。之後，會訪問到B的前驅結點A指向B，那麼令A的右指標為空，繼續遍歷B的右孩子。依次類推。 一棵二叉樹

前序遍歷

與中序遍歷類似，區別僅僅是輸出的順序不同。

void preOrder3(TreeNode *root) {
    if(root == NULL)
        return;
    TreeNode *pNode = root;
    while(pNode) {
        if(pNode->left == NULL) {
            cout << pNode->val << endl;
            pNode = pNode->right;
        }   
        else {
            TreeNode *pPre = pNode->left;
            while(pPre->right != NULL && pPre->right != pNode)
                pPre = pPre->right;

            if(pPre->right == NULL) {
                pPre->right = pNode;
                cout << pNode->val << endl;
                pNode = pNode->left;
            }   
            else {
                pPre->right = NULL;
                pNode = pNode->right;
            }   
        }   
    }   
}

後序遍歷

  1. 先建立一個臨時結點dummy，並令其左孩子為根結點root，將當前結點設定為dummy；
  2. 如果當前結點的左孩子為空，則將其右孩子作為當前結點；
  3. 如果當前結點的左孩子不為空，則找到其在中序遍歷中的前驅結點
    • 如果前驅結點的右孩子為空，將它的右孩子設定為當前結點，將當前結點更新為當前結點的左孩子；
    • 如果前驅結點的右孩子為當前結點，倒序輸出從當前結點的左孩子到該前驅結點這條路徑上所有的結點。將前驅結點的右孩子設定為空，將當前結點更新為當前結點的右孩子。
  4. 重複以上過程，直到當前結點為空。
void reverse(TreeNode *p1, TreeNode *p2) {
    if(p1 == p2) 
        return;
    TreeNode *x = p1; 
    TreeNode *y = p1->right;
    while(true) {
        TreeNode *temp = y->right;
        y->right = x;
        x = y;
        y = temp;
        if(x == p2) 
            break;
    }   
}

void printReverse(TreeNode *p1, TreeNode *p2) {
    reverse(p1, p2);

    TreeNode *pNode = p2; 
    while(true) {
        cout << pNode->val << endl;
        if(pNode == p1) 
            break;
        pNode = pNode->right;
    }   

    reverse(p2, p1);
}

void postOrder3(TreeNode *root) {
    if(root == NULL)
        return;

    TreeNode *dummy = new TreeNode(-1);
    dummy->left = root;
    TreeNode *pNode = dummy;
    while(pNode != NULL) {
        if(pNode->left == NULL)
            pNode = pNode->right;
        else {
            TreeNode *pPrev = pNode->left;
            while(pPrev->right != NULL && pPrev->right != pNode)
                pPrev = pPrev->right;

            if(pPrev->right == NULL) {
                pPrev->right = pNode;
                pNode = pNode->left;
            }
            else {
                printReverse(pNode->left, pPrev);
                pPrev->right = NULL;
                pNode = pNode->right;
            }
        }
    }
}

相關推薦

SparkSQL中的三種Join及其實現（broadcast join、shuffle hash join和sort merge join）

1.小表對大表（broadcast join） 將小表的資料分發到每個節點上，供大表使用。executor儲存小表的全部資料，一定程度上犧牲了空間，換取shuffle操作大量的耗時，這在SparkSQL中稱作Broadcast Join Broadcast Jo

二叉樹三種遍歷方式

二叉樹的遍歷，如果是手工畫圖，還可以使用投影法快速得到遍歷序列。 以下圖二叉樹為例，講解投影法快速得到遍歷序列的過程。 （1）          中序遍歷 中序遍歷就像在無風的情況下，太陽直射

二叉樹三種遍歷方式及通過兩種遍歷重構二叉樹（java實現）

重構方法參考文章【重構二叉樹（Java實現）：https://blog.csdn.net/wangbingcsu/article/details/51372695】 文章目錄 二叉樹類 三種遍歷方式 前序遍歷 中序遍歷 後序遍歷

二叉樹三種遍歷方式的遞迴和迴圈實現

轉載自：http://blog.csdn.net/pi9nc/article/details/13008511 二叉樹是一種非常重要的資料結構，很多其他資料機構都是基於二叉樹的基礎演變過來的。二叉樹有前、中、後三種遍歷方式，因為樹的本身就是用遞迴定義的，因此採用遞迴的方

二叉樹三種遞迴遍歷方式

    /**       *       * 遞迴先序遍歷       */     publicstaticvoid preOrderRec(Node root){           if(r

對於二叉樹三種非遞迴遍歷方式的理解

解決二叉樹的很多問題的方案都是基於對二叉樹的遍歷。遍歷二叉樹的前序，中序，後序三大方法算是計算機科班學生必寫程式碼了。其遞迴遍歷是人人都能信手拈來，可是在手生時寫出非遞迴遍歷恐非易事。正因為並非易事，所以網上出現無數的介紹二叉樹非遞迴遍歷方法的文章。可是大家需要的真是那些非遞迴遍歷程式碼和講述嗎？程式碼早

二叉樹三種遍歷方式，先序、中序、後序

二叉樹遍歷方式分為三種：先序，中序和後序。 可以以根節點的位置為參考來記遍歷方式，在第一個為先序，中間為中序，最後為後序； 即：先序： 根左右；中序：左根右；後序：左右根。 借個圖： 每個節點左上角，底部，右上角分別對應先序，中序，後序時的取值點

【圖解資料結構】 一組動畫徹底理解二叉樹三種遍歷

二叉樹的遍歷是指從根結點出發，按照某種次序依次訪問二叉樹中所有結點，使得每個結點被訪問一次且僅被訪問一次。 在二叉樹的遍歷中存在三種較為常用的遍歷方式：前序遍歷、中序遍歷、後序遍歷。接下來我將嘗試著用三組動畫向讀者詳細的介紹這三種遍歷方式的邏輯思路，希望讓讀者看到任何的二叉樹都能在腦海中快速的勾勒出動畫。

Java實現二叉樹三種遍歷演算法

</pre><p></p><p>參考網上一些資料測試整理了一下二叉樹遍歷的Java實現程式碼。</p>二叉樹三種遍歷方式：先序遍歷、中序遍歷、後序遍歷。<p>首先定義二叉樹類：</p>&l

資料結構二叉樹三種非遞迴的遍歷

#include <stdio.h> #include <malloc.h> #define MAX 30 typedef struct TiNode {char date;struct TiNode *lchild;struct TiNode *r

二叉樹三種遍歷六種實現

二叉樹是一種非常重要的資料結構，很多其他資料機構都是基於二叉樹的基礎演變過來的。二叉樹有前、中、後三種遍歷方式，因為樹的本身就是用遞迴定義的，因此採用遞迴的方法實現三種遍歷，不僅程式碼簡潔且容易理解，但其開銷也比較大，而若採用非遞迴方法實現三種遍歷，則要用棧來模擬實現

二叉樹三種遍歷遞迴及非遞迴實現

二叉樹的三種遍歷方式包括： 前序遍歷中序遍歷後序遍歷 三種遍歷的遞迴方法都非常好實現，而且簡單易懂。非遞迴實現也是通過使用棧來模擬遍歷的過程。順便提一句，能用遞迴做的，基本都能用棧來實現。前序遍歷和中序遍歷的非遞迴寫法相對比較簡單，只需要模擬遍歷過程即可。後序遍歷非遞迴寫

層次遍歷二叉樹-三種不同的方法

給定一棵二叉樹，要求進行分層遍歷，每層的節點值單獨列印一行，下圖給出事例結構： 對此二叉樹遍歷的結果應該是： 1， 2 ， 3 4， 5， 6 7， 8 第一種方法，就是利用遞迴的方法，按層進行列印，我們把根節點當做第0層，之後層次依次增加，如果我們想列印第二層怎麼辦呢，

二叉樹三種遍歷 (Java)

以前學資料結構的時候是用C學的，現在重新複習一下資料結構裡用的比較多的二叉樹，用Java實現。好啦，廢話不多說啦！！ 我們知道二叉樹有三種遍歷方式：前序(根左右)、中序(左根右)、後序(左右根)。每種遍歷方式其實就是一個遞迴呼叫。 步驟： 1、將陣列中的元素賦值給二叉樹（通

二叉樹三種遍歷的非遞迴思路（JAVASCRIPT)

二叉樹在圖論中是這樣定義的：二叉樹是一個連通的無環圖，並且每一個頂點的度不大於3。有根二叉樹還要滿足根結點的度不大於2。有了根結點之後，每個頂點定義了唯一的父結點，和最多2個子結點。然而，沒有足夠的資訊來區分左結點和右結點。如果不考慮連通性，允許圖中有多個連通分

二叉樹三種遍歷非遞迴演算法

1.先序遍歷非遞迴演算法 #define maxsize 100 typedef struct {     Bitree Elem[maxsize];     int top; } SqStack; void PreOrderUnrec(Bitree t) {     SqStack s;     Stack

資料結構實驗之二叉樹三：統計葉子數（有返回值版）

Problem Description 已知二叉樹的一個按先序遍歷輸入的字元序列，如abc,de,g,f, (其中,表示空結點)。請建立二叉樹並求二叉樹的葉子結點個數。 Input 連續輸入多組資料，每組資料輸入一個長度小於50個字元的字串。 Output 輸出

二叉樹的三種遍歷方式（遞迴、非遞迴和Morris遍歷）

二叉樹遍歷是二叉樹的最基本的操作，其實現方式主要有三種： 遞迴遍歷 非遞迴遍歷 Morris遍歷 遞迴遍歷的實現非常容易，非遞迴實現需要用到棧。而Morris演算法可能很多人都不太熟悉，其強大之處在於只需要使用O(1)的空間就能實現對二叉樹O(n)時間的

二叉樹幾種遍歷方式之間的轉換

寫在前面 二叉樹的遍歷方式，基本可以歸結為四種：前序遍歷、中序遍歷、後序遍歷、層次遍歷 先序遍歷順序：根，左兒子，右兒子 中序遍歷順序：左兒子，根，右兒子 後序遍歷順序：左兒子，右兒子，根 層次遍歷順序：根據每一層的順序，由左向右依次輸出 遍歷順序及轉換  &n

二叉樹四種遍歷方式的速度差異

同學阿里三面面試官的一道面試題是：二叉樹每個節點都儲存一個整數，想要求所有節點數值之和，哪種遍歷方式最快？ 首先定義二叉樹 struct Tree { int val; Tree *left; Tree *right; Tre