二叉樹遍歷算法

首先，個人認為，二叉樹是很能體會遞歸算法思想的，因為二叉樹的結構是leftTree->root<-rightTree，對於每個非葉子節點，該規律都適用，因此關於二叉樹的很多算法也都能用遞歸思想搞定。遞歸的優點在於代碼簡潔，但效率卻是問題。其次，對於各種順序的遍歷，又有着相應的非遞歸算法，非遞歸算法的代碼量相對大一點，但更容易掌控，而且效率更優。

先看節點結構：

struct Bitree{
  int val;
  Bitree *left, *right;
  Bitree(int x):val(x), left(nullptr), right(nullptr){
  };
};

 

1. 中序遍歷

•  遞歸算法

顯然，中序遍歷的順序為leftTree， root， rightTree，顯然先遍歷左子樹，然后是根，最后右子樹。中序遍歷的遞歸算法自然也就出來了。

void inOrderTraverse1(Bitree *root){
  if(root){
    inOrderTraverse1(root->left);
    visit(root);
    inOrderTraverse1(root->right);
  }
}

• 非遞歸算法1.

非遞歸算法的思想也比較簡單，按從左到右進行訪問。先指針往左探尋到底，然后觀察最后一個非空節點是否有右節點，若有，將該右節點作為新的探尋起點，再進行下一輪的探尋。顯然，“一探到底”的思路需要使用stack來幫助緩存之前的節點。

void inOrderTraverse2(Bitree *root){
  stack<Bitree *> S;
  S.push(root);
  Bitree *p = root;
  while(!S.empty()){
    p = S.top();
    while(p){
      S.push(p->left);
      p = p->left;
    }
    S.pop();//pop out the nullptr
    if(!S.empty()){
      p = S.top();
      visit(p);
      S.pop();
      S.push(p->right);//push its right child into the stack
    }
  }
}

• 非遞歸算法2

void inOrderTraverse3(Bitree *root){
  stack<Bitree *> S;
  Bitree *p = root;
  while(p || !S.empty()){
    if(p){
      S.push(p);
      p = p->left;
    }else{
      p = S.top();
      visit(p);
      S.pop();
      p = p->right;
    }
  }
}

個人認為，雖然兩種非遞歸算法的思路完全一樣，但非遞歸算法2比非遞歸算法1代碼要更為簡潔，更值得推薦。

 

2. 前序遍歷

• 遞歸算法

前序遍歷的順序為root，leftTree，rightTree，直接上代碼

void preOrderTraverse1(Bitree *root){
  if(root){
    visit(root);
    preOrderTraverse1(root->left);
    preOrderTraverse1(root->right);
  }
}

• 非遞歸算法1

對於前序遍歷的非遞歸算法，和中序遍歷的非遞歸算法非常相似，不過是在進棧時就訪問該節點，而不是之后再訪問。由於代碼相似，先給出一種

void preOrderTraverse2(Bitree *root){
  stack<Bitree *> S;
  Bitree *p = root;
  while(p || !S.empty()){
    if(p){
      visit(p);
      S.push(p);
      p = p->left;
    }else{
      p = S.top();
      S.pop();
      p = p->right;
    }
  }
}

•  非遞歸算法2

該算法采用了和前序遍歷相同的思想，即root節點先進棧，root節點出棧時，將其右節點先進棧，然后是左節點進棧。這樣，利用棧先進后出的性質，訪問順序自然變為了root，左子樹，右子樹。

void preOrderTraverse3(Bitree *root){
  if(!root){
    return;
  }
  stack<Bitree *> S;
  Bitree *p = root;
  S.push(root);
  while(!S.empty()){
    p = S.top();
    visit(p);
    S.pop();
    if(p->right){
      S.push(p->right);
    }
    if(p->left){
      S.push(p->left);
    }
  }
}

 

3. 后續遍歷

• 遞歸算法

后續遍歷的順序是leftTree，rightTree和root，因此遞歸算法也自然出來了

void postOrderTraverse1(Bitree *root){
  if(root){
    postOrderTraverse1(root->left);
    postOrderTraverse1(root->right);
    visit(root);
  }
}

• 非遞歸算法1

和之前中序和前序算法不同，后續遍歷的root節點要最后才能被訪問，因此，我們若想訪問某節點，那么我們需要知道該節點的右節點是否已經被訪問過。只有該節點的右節點為null，或者已被訪問過，那么該節點才能被訪問；否則需要先將右節點訪問完。為了判斷該節點的右節點是否已經被訪問過，需另外設一個記錄指針last來指示已經訪問過的節點，如果之前訪問過的節點last恰為該節點的右節點，說明其右子樹已經訪問完，應該訪問該節點。

void postOrderTraverse2(Bitree *root){
  Bitree *last = nullptr;
  Bitree *p = root;
  stack<Bitree *> S;
  while(p || !S.empty()){
    while(p){
      S.push(p);
      p = p->left;
    }
    p = S.top();
    if(p->right && p->right != last){
      p = p->right;
    }else{
      visit(p);
      S.pop();
      last = p;
      p = nullptr;//p needs to be updated to null for next loop
    }
  }
}

tip 1：后續遍歷中，root節點最后才能被訪問到，因此，棧能記錄每一個節點的路徑，包括葉子節點。這一點性質可用於求解和樹的路徑有關的問題。

•  非遞歸算法2

和前序遍歷的非遞歸算法2一樣，這里也給出后續遍歷對應的非遞歸算法2，思路也是類似。由於后序遍歷中，根節點要最后才能被訪問到，不像前序遍歷中剛訪問到便可以輸出。但在實際查找過程中，我們又只能先從根節點開始查找，才能接着查找左子樹和右子樹，由此可以再利用棧先進后出的特性來存儲根節點。

void postOrderTraverse3(Bitree *root){
  if(!root){
    return;
  }
  Bitree *p = root;
  stack<Bitree *> S;
  stack<Bitree *> postOrder;
  S.push(p);
  while(!S.empty()){
    p = S.top();
    postOrder.push(p);
    S.pop();
    if(p->left){
      S.push(p->left);//first IN, later OUT
    }
    if(p->right){
      S.push(p->right);//later IN, first OUT
    }
  }
  while(!postOrder.empty()){
    p = postOrder.top();
    visit(p);
    postOrder.pop();
  }
}

 

4. 層序遍歷

層序遍歷的思想和之前三種遍歷方式不同，需要借助queue來對節點進行緩存，先進隊列的節點需要先離開。這和圖的BFS思想一樣，畢竟樹本質上也是一種特殊的圖。

void levelOrderTraverse(Bitree *root){
  if(!root){
    return;
  }
  queue<Bitree *> Q;
  Bitree *p = nullptr;
  Q.push(root);
  while(!Q.empty()){
    p = Q.front();
    Q.pop();
    visit(p);
    if(p->left){
      Q.push(p->left);
    }
    if(p->right){
      Q.push(p->right);
    }
  }
}

Tip 2: 層序遍歷思想簡單，利用queue來一層一層輸出。因此，可用於求解數的寬度和高度。