二叉樹的遍歷大致可分為先序遍歷、中序遍歷、後序遍歷和層次遍歷四種。具體的實現原理都比較簡單，這裡不再描述，現在給出具體的遍歷演算法。本文給出了二叉樹遍歷的遞迴演算法和非遞迴演算法，這樣有助於對照了解。

二叉樹的結構體

   typedef struct BinTreeNode
   {  
       int data;  // 預設結點中儲存整型資料
       struct BinTreeNode* lchild;  
       struct BinTreeNode* rchild;  
   };

1、前序遍歷

1、前序遞迴

   void
 
 PreOrder(BinTreeNode *root)   // 前序遞迴
   {
       if(root!=NULL)
       {
           cout<<root->data<<" ";
           PreOrder(root->lchild);
           PreOrder(root->rchild);
       }
   }

2、前序非遞迴

   void PreOrder(BinTreeNode *root)  // 前序非遞迴
   {
       stack<BinTreeNode*>
 
 s;
       BinTreeNode *p = root;
       while(p!=NULL||!s.empty())
       {
           while(p!=NULL)
           {
               cout<<p->data<<" ";
               s.push(p);
               p=p->lchild;
           }
           if(!s.empty())
           {
               p = s.top();
               s.pop();
               p = p->rchild;
           }
       }
   }
 

2、中序遍歷

1、中序遞迴

   void InOrder(BinTreeNode *root)  // 中序遞迴
   {
       if(root!=NULL)
       {
           InOrder(root->lchild);
           cout<<root->data<<" ";
           InOrder(root->rchild);
       }
   } 

2、中序非遞迴

   void InOrder(BinTreeNode *root)  // 中序非遞迴
   {
       stack<BinTreeNode*> s;
       BinTreeNode *p = root;
       while(p!=NULL||!s.empty())
       {
           while(p!=NULL)
           {
               s.push(p);
               p = p->lchild;
           }
           if(!s.empty())
           {
               p = s.top();
               cout<<p->data<<" ";
               s.pop();
               p = p->rchild;
           }
       }    
   } 

3、後序遍歷

1、後序遞迴

   void PostOrder(BinTreeNode *root)  // 後序遞迴
   {
       if(root!=NULL)
       {
           PostOrder(root->lchild);
           PostOrder(root->rchild);
           cout<<root->data<<" ";
       }    
   }

2、後序非遞迴

   void PostOrder(BinTreeNode *root)  // 後序非遞迴
   {
       stack<BinTreeNode*> s;
       BinTreeNode *p = root, *r = NULL;
       while(p||!s.empty())
       {
           if(p)  // 走到最左邊
           {
               s.push(p);
               p=p->lchild;
           }
           else  // 向右
           {
               p = s.top();
               if(p->rchild&&p->rchild!=r)  // 右子樹存在且未被訪問
               {
                   p = p->rchild;
                   s.push(p);
                   p = p->lchild;
               }
               else  // 否則，彈出結點並訪問
               {
                   p = s.top();
                   s.pop();
                   cout<<p->data<<" ";
                   r = p;
                   p =NULL;
               }
           }  // else
       }  // while  
   } 

4、層次遍歷

   void LevelOrder(BiTreeNode* root)  // 層次非遞迴
   {  
       queue<BiTreeNode*> q;
       BiTreeNode* p = root;    
       q.push(p);  
   
       while(!q.empty())
       {  
           p = q.front();  
           cout<<p->data<<" ";  
           q.pop();  
   
           if(p->lchild != NULL)
           {  
               q.push(p->lchild);  
           }  
   
           if(p->rchild != NULL)
           {  
               q.push(p->rchild);  
           }  
       }  
   }