基本上所有關於二叉樹的操作都是基於二叉樹的遍歷演算法來實現的，因此在這裡講一下二叉樹的遍歷演算法，其中包括遞迴與非遞迴演算法，在演算法中用輸出節點資料來代替對節點的操作。
首先給出這樣一棵數：

1、前序遍歷
所謂前序遍歷就是先對節點資料進行處理，然後才對這個節點的左右子樹進行處理。對這棵二叉樹的前序遍歷結果為：ABDCEFG。
遞迴：

    void _PreOrder(PNode& pRoot)
    {
        if (pRoot)
        {
            cout << pRoot->_data <<
 
 " ";
            _PreOrder(pRoot->_LChild);
            _PreOrder(pRoot->_RChild);
        }
    }
    void PreOrder()
    {
        _PreOrder(_pRoot);
        cout << endl;
    }

非遞迴：
非遞迴方式需要用到棧，這裡給出兩種演算法：
第一種：

void PreOrder_Nor1()
      {
           if(NULL == _pRoot)
               return
 
;
           stack<pNode> s;
           s.push(_pRoot);
           pNode pTemp = NULL;
           while(!s.empty())
           {
               pTemp = s.top();
               cout<< pTemp->_data << " ";
               s.pop();
               if(NULL != pTemp->_RChild)
                   s.push(pTemp->_RChild);
               if
 
(NULL != pTemp->_LChild)
                   s.push(pTemp->_LChild);
           }
           cout<<endl;
      }

第二種：

      void PreOrder_Nor2()
      {
           if(NULL == _pRoot)
               return;
           stack<pNode> s;
           s.push(_pRoot);
           pNode cur = NULL;
           while(!s.empty())
           {
                   cur = s.top();
                   s.pop();
                   while(cur)
                   {
                       cout<< cur->_data << " ";
                       if(cur->_RChild)
                           s.push(cur->_RChild);
                       cur = cur->_LChild;
                   }
            }
            cout<<endl;
     }

呼叫三種方法：

中序遍歷：
中序遍歷順序為左子樹->節點->右子樹，這棵二叉樹的遍歷結果為：BDAECFG
遞迴：

    void _InOrder(PNode& pRoot)
    {
        if (pRoot)
        {
            _InOrder(pRoot->_LChild);
            cout << pRoot->_data << " ";
            _InOrder(pRoot->_RChild);
        }
    }
    void InOrder()
    {
        _InOrder(_pRoot);
        cout << endl;
    }

非遞迴：

void InOrder_Nor()
{
    if(NULL == _pRoot)
        return;
    stack<pNode> s;
    pNode cur = _pRoot;
    pNode pPre = NULL;
    while(!s.empty() || cur)
    {
        while(cur && cur != pPre)
        {
            s.push(cur);
            cur = cur->_LChild;
        }
        if(s.empty())
            return;
        cur = s.top();
        cout<< cur->_data << " ";
        pPre = cur;
        s.pop();
        cur = cur->_RChild;
    }
    cout<<endl;
}

呼叫兩種中序遍歷演算法：

後序遍歷
後序遍歷順序為：左子樹->右子樹->節點，這棵二叉樹的遍歷結果為DBEGFCA
遞迴：

    void _PostOrder(PNode& pRoot)
    {
        if (pRoot)
        {
            _PostOrder(pRoot->_LChild);
            _PostOrder(pRoot->_RChild);
            cout << pRoot->_data << " ";
        }
    }
    void PostOrder()
    {
        _PostOrder(_pRoot);
        cout << endl;
    }

非遞迴：

      void PostOrder_Nor()
      {
          if(NULL == _pRoot)
              return;
          stack<pNode> s;
          s.push(_pRoot);
          pNode cur = _pRoot->_LChild;
          pNode pPre = NULL;
          while(!s.empty())
          {
              while(cur && cur!= pPre)
              {
                  s.push(cur);
                  cur = cur->_LChild;
              }
              if(s.empty())
                  return;
              cur = s.top();
              if(cur->_RChild && cur->_RChild != pPre)
              {
                  cur = cur->_RChild;
              }
              else
              {
                  cout<< cur->_data << " ";
                  pPre = cur;
                  s.pop();
              }
         }
         cout<<endl;
     }

呼叫兩種方法：

層序遍歷
層序遍歷演算法不同於前序、中序、後序演算法，層序遍歷用遞迴方式實現比較困難，一般用佇列結合迴圈實現比較簡單。其基本思想是從根節點開始一層一層的從上向下遍歷，其過程為：

因此層序遍歷的結果為：ABCDEFG
其程式碼實現為:

    void LevelOrder()
    {
        queue<PNode> q;
        if (_pRoot)
            q.push(_pRoot);
        while (!q.empty())
        {
            PNode tmp = q.front();
            cout << tmp->_data << " ";
            if (tmp->_LChild)
                q.push(tmp->_LChild);
            if (tmp->_RChild)
                q.push(tmp->_RChild);
            q.pop();
        }
        cout << endl;
    }

遍歷結果：

演算法實現還有待改進，望高手斧正！