二叉樹分層遍歷

首先定義二叉樹的存儲結構：

　　

struct TreeNode {
    int val;
    TreeNode *left;
    TreeNode *right;

    TreeNode(int v, TreeNode* l = NULL, TreeNode *r = NULL)
        :val(v), left(l), right(r) {}
};

 

1.遞歸的方法（《編程之美》3.10）

　　二叉樹本身就帶有遞歸屬性，通常我們可以用遞歸方法解決。假設要訪問第k層節點，那么其實可以轉皇城分別訪問“以該二叉樹根節點的左右子節點為根節點的兩棵子樹”中層次為k-1的節點。此方法需要求出二叉樹的深度，其實可以直接訪問到二叉樹某一層次失敗的時候返回就可以了。

　　這個方法的問題是遞歸調用，效率較低。而且對每一層的訪問都需要從根節點開始，效率極差。

　　最壞的情況下（不平衡樹）時間復雜度為O(n^2),空間復雜度O(1)

//輸出以root為根節點中的第level層中的所有節點（從左至右），成功返回1
//失敗返回0
//root為二叉樹根節點
//level為層次數，其中根節點為第0層
int PrintNodeAtLevel(TreeNode *root, int level) {
    if (!root || level < 0) return 0;
    if (level == 0){
        cout<<root->val;
        return 1;
    }

    return PrintNodeAtLevel(root->left, level - 1) + PrintNodeAtLevel(root->right, level - 1);
}

//層次遍歷二叉樹
//root，二叉樹的根節點
void LevelOrder(TreeNode *root) {
    for (int level = 0; ; level++) {
        if (!PrintNodeAtLevel(root, level)) 
            break;
        cout<<endl;
    }
}

 

2. 使用數組和兩個游標的方法（《編程之美》 3.10）

　　在訪問k層的時候，我們只需要知道k-1層的信息就足夠了，所以在訪問第k層的時候，要是能夠知道k-1層的節點信息，就不再需要從根節點開始遍歷了。

　　根據上述分析，可以從根節點出發，依次將每一層的根節點從左往右壓入一個數組，並並用一個游標cur記錄當前訪問的節點，另一個游標last指示當前層次的最后一個節點的下一個位置，以cur===last作為當前層次訪問結束的條件，在訪問某一層的同時將該層的所有節點的子節點壓入數組，在訪問完某一層之后，檢查是否還有新的層次可以訪問，直到檢查完所有的層次（不再有新的節點可以訪問）

　　這種方法需要一個vector一直存儲所有節點，空間效率較差。

　　時間復雜度為O(n),空間復雜度為O(n)

void LevelOrder(TreeNode *root) {
    if (root == NULL) return;
    vector<TreeNode *> vec; //這里使用stl中的vector代替數組，可利用到
                            //其動態擴展的屬性
    vec.push_back(root);
    int cur = 0, last = vec.size();
    while (cur < vec.size()) {
        last = vec.size();

        while (cur < last) {
            cout<<vec[cur]->val;
            if (vec[cur]->left) 
                vec.push_back(vec[cur]->left);
            if(vec[cur]->right)
                vec.push_back(vec[cur]->right);
            ++cur;
        }
        cout<<endl;
    }
}

 

3. 兩個隊列的方法

　　廣度優先搜索的思想。使用兩個隊列，一個記錄當前層的節點，另一個記錄下一層的節點。輸出當前層節點后交換，使下一層的節點稱為當前層的節點。

　　時間復雜度O(n),空間復雜度O(1)

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

    queue<TreeNode *> current, next;
    
    current.push(root);
    while (!current.empty()) {
        while (!current.empty()) {
            TreeNode * p = current.front();
            cout<<p->val<<" ";
            current.pop();
            if (p->left)
                next.push(p->left);
            if (p->right)
                next.push(p->right);
        }
        cout<<endl;
        swap(next, current);
    }
}

 

4.使用一個隊列和兩個標記的方法

　　使用current記錄當前節點的數量，nextlevel記錄下一層節點的數量。當current==0時就將下一層置為當前層。

　　

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

    queue<TreeNode *> q;
    q.push(root);
    int nextlevel = 0; //記錄下一層節點的數量
    int current = 1; //記錄當前層節點的數量

    while (!q.empty()) {
        TreeNode *p = q.front();
        q.pop();
        --current;
        cout<<p->val<<" ";

        if (p->left) {
            q.push(p->left);
            ++nextlevel;
        }
        if (p->right) {
            q.push(p->right);
            ++nextlevel;
        }

        if（current == 0) {
            cout<<endl;
            swap(current, nextlevel);
        }
    }
}

 

　　

5. 使用一個隊列加一個標記的方法

　　用隊列暫存儲節點，每當一層節點進入隊列，就在最后加入一個空指針表示當前層結束。

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

    queue<TreeNode *> q;
    q.push(root);
    q.push(0);
    while (!q.empty()) {
        TreeNode *p =q.front();
        q.pop();
        if (p) {
            cout<<p->val<<" ";
            if (p->left)
                q.push(p->left);
            if (p->right)
                q.push(p->right);
            //當發現空指針（結束信號時），要檢查隊列是夠還有節點
            //如果沒有的話還插入新的結束信號，則會造成死循環
        } else if (!q.empty()) {
            q.push(0);
            cout<<endl;
        }
    }
}

 

 參考資料：

　　　　　1.《編程之美》

　　　　　2. 《劍指offer》

　　　　　2. http://www.cnblogs.com/miloyip/archive/2010/05/12/binary_tree_traversal.html