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

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

同學阿里三面面試官的一道面試題是：二叉樹每個節點都儲存一個整數，想要求所有節點數值之和，哪種遍歷方式最快？

首先定義二叉樹

struct Tree
{
    int val;
    Tree *left;
    Tree *right;
    Tree(){val = 0;left = NULL;right = NULL;};
};

Tree* constructTree(vector<int> &vect, int i)
{
    if(i >= vect.size())
        return NULL;
    Tree *root = new Tree();
    root->val = vect[i];
    root->left = constructTree(vect, 2*i+1);
    root->right = constructTree(vect, 2*i+2);
}

void releaseTree(Tree *root)
{
    if(root == NULL)
        return;
    release(root->left);
    release(root->right);
    delete root;
}

二叉樹有四種遍歷方式，先序遍歷、中序遍歷、後序遍歷、層次遍歷。分別利用這些遍歷方式進行二叉樹所有元素求和：

一、遞迴方式

層次遍歷只能通過非遞迴的方式實現，下面只給出先序遍歷、中序遍歷、後續遍歷的三種遞迴實現方式。

//遞迴的先序遍歷求和
void frontTraverseSum(Tree *root, int &sum)
{
    if(root == NULL)
        return;
    sum += root->val;
    frontTraverseSum(root->left, sum);
    frontTraverseSum(root->right, sum);
}

//遞迴的中序遍歷求和
void middleTraverseSum(Tree *root, int &sum)
{
    if(root == NULL)
        return;
    middleTraverseSum(root->left, sum);
    sum += root->val;
    middleTraverseSum(root->right, sum);
}

//遞迴的後續遍歷求和
void backTraverseSum(Tree *root, int &sum)
{
    if(root == NULL)
        return;
    backTraverseSum(root->left, sum);
    backTraverseSum(root->right, sum);
    sum += root->val;
}

二、非遞迴方式

//非遞迴的先序遍歷求和,並使用count統計入棧次數
void preTraverseSum(Tree *root, int &sum)
{
    stack<Tree*> st;
    Tree *p = root;
    int count = 0;
    while(p != NULL || !st.empty())    //當出棧到root的時候會出現棧為空的中間狀態，所以p不為空的條件不能省略
    {
        while(p != NULL)
        {
            sum += p->val;
            st.push(p);
            count++;
            p = p->left;
        }
        if(!st.empty())
        {
            p = st.top();
            st.pop();
            p = p->right;
        }
    }
    cout << "pre st.push count: " << count << endl;
}

//非遞迴的中序遍歷求和
void inTraverseSum(Tree *root, int &sum)
{
    stack<Tree*> st;
    Tree *p = root;
    int count = 0;
    while(p != NULL || !st.empty())
    {
        while(p != NULL)
        {
            st.push(p);
            count++;
            p = p->left;
        }
        if(!st.empty())
        {
            p = st.top();
            st.pop();
            sum += p->val;
            p = p->right;
        }
    }
    cout << "in st.push count: " << count << endl;
}

//非遞迴的後序遍歷求和, 這個比先序遍歷和中序遍歷複雜，需要判斷出棧條件：左右孩子均為空或者左右孩子被訪問過
void postTraverseSum(Tree *root, int &sum)
{
    stack<Tree*> st;
    Tree *cur = root;
    Tree *pre = NULL;
    st.push(root);
    int count = 1;
    while(!st.empty())
    {
        cur = st.top();
        if((cur->left == NULL && cur->right == NULL) || (pre != NULL && (pre == cur->left || pre == cur->right)))
        {
            sum += cur->val;
            st.pop();
            pre = cur;
        } else {
            if(cur->right)
            {
                st.push(cur->right);
                count++;
            }
            if(cur->left)
            {
                st.push(cur->left);
                count++;
            }
        }
    }   
    cout << "post st.push count: " << count << endl;
}

//只能非遞迴的層次遍歷
void levelTraverseSum(Tree*root, int &sum)
{
    queue<Tree*> qu;
    Tree *p = root;
    qu.push(root);
    while(!qu.empty())
    {
        p = qu.front();
        sum += p->val;
        qu.pop();
        if(p->left)
            qu.push(p->left);
        if(p->right)
            qu.push(p->right);
    }
}

三、測試每種遍歷方式的時間

全都採用相同的模板：

void test(Tree *root)
{
    int sum = 0;
    clock_t beg = clock();
    traverseSum(root, sum);
    clock_t end = clock();
    cout << "time: " << end - beg << endl;
    cout << "sum: " << sum << endl;
}

int main()
{
    vector<int> vect;
    for(int i = 0; i < 7000000; i++)
    {
        vect.push(i);
    }
    Tree *root;
    root = construct(vect, 0);
    test();
    releaseTree(root);
    return 0;
}

四、執行結論

在規模小的二叉樹上沒有太大差異，對於大的二叉樹，遞迴遍歷都快於非遞迴遍歷，但是每次執行的結果都有差異，一般來講中序遍歷是執行比較快的，後序遍歷和層次遍歷最慢：

一次執行結果：

7000000
front time: 50000
front sum: 1503043616
middle time: 40000
middle sum: 1503043616
back time: 40000
back sum: 1503043616
level time: 510000
level sum: 1503043616
pre st.push count: 7000000
pre time: 470000
pre sum: 1503043616
in st.push count: 7000000
in time: 460000
in sum: 1503043616
post st.push count: 7000000
post time: 530000
post sum: 1503043616

重複執行一次結果：

7000000
front time: 50000
front sum: 1503043616
middle time: 40000
middle sum: 1503043616
back time: 50000
back sum: 1503043616
level time: 500000
level sum: 1503043616
pre st.push count: 7000000
pre time: 480000
pre sum: 1503043616
in st.push count: 7000000
in time: 450000
in sum: 1503043616
post st.push count: 7000000
post time: 540000
post sum: 1503043616

五、完整程式碼

#include <iostream>
#include <vector>
#include <queue>
#include <stack>
#include <ctime>
using namespace std;

struct Tree
{
    int val;
    Tree *left;
    Tree *right;
    Tree(){val = 0; left = NULL; right = NULL;};
};

void frontTraverseSum(Tree *root, int &sum)
{
    if(root == NULL)
    return;
    sum += root->val;
    frontTraverseSum(root->left, sum);
    frontTraverseSum(root->right, sum);
}

void middleTraverseSum(Tree *root, int &sum)
{
    if(root == NULL)
    return;
    middleTraverseSum(root->left, sum);
    sum += root->val;
    middleTraverseSum(root->right, sum);
}

void backTraverseSum(Tree *root, int &sum)
{
    if(root == NULL)
    return;
    backTraverseSum(root->left, sum);
    backTraverseSum(root->right, sum);
    sum += root->val;
}

void test1(Tree *root)
{
    int sum = 0;
    clock_t beg = clock();
    frontTraverseSum(root, sum);
    clock_t end = clock();
    cout << "front time: " << end - beg << endl;
    cout << "front sum: " << sum << endl;
}

void test2(Tree *root)
{
    int sum = 0;
    clock_t beg = clock();
    middleTraverseSum(root, sum);
    clock_t end = clock();
    cout << "middle time: " << end - beg << endl;
    cout << "middle sum: " << sum << endl;
}

void test3(Tree *root)
{
    int sum = 0;
    clock_t beg = clock();
    backTraverseSum(root, sum);
    clock_t end = clock();
    cout << "back time: " << end - beg << endl;
    cout << "back sum: " << sum << endl;
}

Tree* constructTree(vector<int> &vect, int k)
{
    if(k >= vect.size())
        return NULL;
    Tree *root = new Tree();
    root->val = vect[k];
    //cout << root->val << " ";
    root->left = constructTree(vect, 2*k+1);
    root->right = constructTree(vect, 2*k+2);
    return root;
}

void levelTraverseSum(Tree *root, int &sum)
{
    queue<Tree*> qu;
    qu.push(root);
    while(!qu.empty())
    {
    Tree *father = qu.front();
    qu.pop();
    sum += father->val;
    if(father->left)
        qu.push(father->left);
    if(father->right)
        qu.push(father->right);
    }
}

void test4(Tree *root)
{
    int sum = 0;
    clock_t beg = clock();
    levelTraverseSum(root, sum);
    clock_t end = clock();
    cout << "level time: " << end - beg << endl;
    cout << "level sum: " << sum << endl;
}

void levelTraverse(Tree *root)
{
    queue<Tree*> qu;
    qu.push(root);
    while(!qu.empty())
    {
    Tree *father = qu.front();
    qu.pop();
    cout << father->val << " ";
    if(father->left)
        qu.push(father->left);
    if(father->right)
        qu.push(father->right);
    }
    cout << endl;
}

void releaseTree(Tree *root)
{
    if(root == NULL)
    return;
    releaseTree(root->left);
    releaseTree(root->right);
    delete root;
}

void preTraverse(Tree *root)
{
    stack<Tree*> st;
    Tree *p = root;
    while(p != NULL || !st.empty())
    {
    while(p != NULL)
    {
        cout << p->val << " ";
        st.push(p);
        p = p->left;
    }
    if(!st.empty())
    {
        p = st.top();
        st.pop();
        p = p->right;
    }
    }
    cout << endl;
}

void preTraverseSum(Tree *root, int &sum)
{
    stack<Tree*> st;
    Tree *p = root;
    int count = 0;
    while(p != NULL || !st.empty())
    {
    while(p != NULL)
    {
        sum += p->val;
        st.push(p);
        count++;
        p = p->left;
    }
    if(!st.empty())
    {
        p = st.top();
        st.pop();
        p = p->right;
    }
    }
    cout << "pre st.push count: " << count << endl;
}

void test5(Tree *root)
{
    int sum = 0;
    clock_t beg = clock();
    preTraverseSum(root, sum);
    clock_t end = clock();
    cout << "pre time: " << end - beg << endl;
    cout << "pre sum: " << sum << endl;
}

void inTraverse(Tree *root)
{
    stack<Tree*> st;
    Tree *p = root;
    while(p != NULL || !st.empty())
    {
    while(p != NULL)
    {
        st.push(p);
        p = p->left;
    }
    if(!st.empty())
    {
        p = st.top();
        cout << p->val << " ";
        st.pop();
        p = p->right;
    }
    }
    cout << endl;
}

void inTraverseSum(Tree *root, int &sum)
{
    stack<Tree*> st;
    Tree *p = root;
    int count = 0;
    while(p != NULL || !st.empty())
    {
    while(p != NULL)
    {
        st.push(p);
        count++;
        p = p->left;
    }
    if(!st.empty())
    {
        p = st.top();
        sum += p->val;
        st.pop();
        p = p->right;
    }
    }
    cout << "in st.push count: " << count << endl;
}

void test6(Tree *root)
{
    int sum = 0;
    clock_t beg = clock();
    inTraverseSum(root, sum);
    clock_t end = clock();
    cout << "in time: " << end - beg << endl;
    cout << "in sum: " << sum << endl;
}

void postTraverse(Tree *root)
{
    stack<Tree*> st;
    Tree *cur = root;
    Tree *p = NULL;
    st.push(root);
    while(!st.empty())
    {
    cur = st.top();
    if((cur->left == NULL && cur->right == NULL) || (p != NULL &&(p == cur->left || p == cur->right)))
    {
        cout << cur->val << " ";
        st.pop();
        p = cur;
    } else {
        if(cur->right)
        st.push(cur->right);
        if(cur->left)
        st.push(cur->left);
    }
    } 
    cout << endl;
}

void postTraverseSum(Tree *root, int &sum)
{
    stack<Tree*> st;
    Tree *cur = root;
    Tree *p = NULL;
    st.push(root);
    int count = 1;
    while(!st.empty())
    {
    cur = st.top();
    if((cur->left == NULL && cur->right == NULL) || (p != NULL && (p == cur->left || p == cur->right)))
    {
        sum += cur->val;
        st.pop();
        p = cur;
    } else {
        if(cur->right)
        {
        st.push(cur->right);
        count++;
        }
        if(cur->left)
        {
        st.push(cur->left);
        count++;
        }
    }
    }
    cout << "post st.push count: " << count << endl;
}

void test7(Tree *root)
{
    int sum = 0;
    clock_t beg = clock();
    postTraverseSum(root, sum);
    clock_t end = clock();
    cout << "post time: " << end - beg << endl;
    cout << "post sum: " << sum << endl;
}

int main()
{
    vector<int> vect;
    for(int i = 0; i < 7000000; i++)
    {
    vect.push_back(i);
    }
    cout << vect.size() << endl;
    Tree *root;
    root = constructTree(vect, 0);
/*    cout << "levelTraverse: ";
    levelTraverse(root);
    cout << "preTraverse: ";
    preTraverse(root);
    cout << "inTraverse: ";
    inTraverse(root);
    cout << "postTraverse: ";
    postTraverse(root); */
    test1(root);
    test2(root);
    test3(root);
    test4(root);
    test5(root);
    test6(root);
    test7(root);
    releaseTree(root);
    return 0;
}

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

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

二叉樹三種遍歷方式

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

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

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

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

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

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

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

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

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

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

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

資料結構筆記：二叉樹的典型遍歷方式

二叉樹是否只有一種遍歷方式（層次遍歷）？典型的二叉樹遍歷方式 -先序遍歷（Pre-Order Traversal） -中序遍歷（In-Order Traversal） -後序遍歷（Post-Order Traversal）先序遍歷（Pre-Order Traversal）

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

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

二叉樹的各種遍歷方式

class TreeNode{ TreeNode root; TreeNode left; TreeNode right; int val; } public class TreeNodeGo{ //深度優先搜尋（先序、中序、後序） public v

二叉樹3種遍歷演算法遞迴與非遞迴實現詳解

一, 二叉樹先序遍歷的實現遞迴實現 void PreOrderTraverse(BiTree T) { if( T ) { VisitF(T->data);//訪問根節點 PreOrderTra

二叉樹三種遍歷六種實現

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

二叉樹幾種遍歷演算法

/*二叉樹的遍歷*/ #include <iostream> #include <cstring> #include <stack> using namespace

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

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

二叉樹三種遍歷 (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

資料結構——二叉樹的四種遍歷方式

首先來說一下哪四種遍歷方式：前中後、層序遍歷，四種遍歷方式詳解，注意這篇部落格用的是STL，但是遍歷思想與遞迴基本一致，體會那種思想即可。前中後序的遞迴區別主要在於輸出的語句究竟該寫在哪裡，這個主要看節點是在什麼位置輸出，如果第一個輸出就在最前面，如果第二個輸出，就在左節點後面。。。以此類

java——二叉樹的四種遍歷方式

按從左到右的思維習慣主要有四種：前、中、後序遍歷主要看你把根節點放在什麼時候遍歷，放在第一個遍歷然後依次遍歷左子樹、右子樹（前序遍歷），先遍歷左子樹、遍歷完了再來遍歷根節點、然後遍歷右子樹，把根節點的遍歷放中間就是（中序遍歷），把根節點放最後遍歷的就是後序遍歷

二叉樹的四種遍歷方式

二叉樹是一種很常見的資料結構，其結構如下圖：下面接受他的四種遍歷方式：先序(先根)遍歷：即先訪問根節點，再訪問左孩子和右孩子中序遍歷：後序遍歷：層次遍歷：按照所在層數，從下往上遍歷前提：這裡先給出測試中的二叉樹結構，如下圖所示該

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

相關推薦