碼上快樂

相關內容    簡體    繁體

二叉樹的遍歷——遞歸和非遞歸

本文轉載自   查看原文   2013-10-31 15:45   9584    二叉樹/ Algorithm and Date structure

       

         二 叉樹是一種非常重要的數據結構，很多其它數據結構都是基於二叉樹的基礎演變而來的。對於二叉樹，有前序、中序以及后序三種遍歷方法。因為樹的定義本身就是 遞歸定義，因此采用遞歸的方法去實現樹的三種遍歷不僅容易理解而且代碼很簡潔。而對於樹的遍歷若采用非遞歸的方法，就要采用棧去模擬實現。在三種遍歷中， 前序和中序遍歷的非遞歸算法都很容易實現，非遞歸后序遍歷實現起來相對來說要難一點。

一.前序遍歷

   前序遍歷按照“根結點-左孩子-右孩子”的順序進行訪問。

  1.遞歸實現

[cpp] view plain copy
  1. void pre_order(BTree *root)    
  2. {    
  3.      if(root != NULL)//必不可少的條件,遞歸的出口    
  4.      {    
  5.         printf("%2c",root->key);    //訪問根結點
  6.         pre_order(root->lchild);     //前序遍歷左子樹
  7.         pre_order(root->rchild);    //前序遍歷右子樹
  8.   
  9.      }    
  10. }    


 2.非遞歸實現

        根據前序遍歷訪問的順序，優先訪問根結點，然后再分別訪問左孩子和右孩子。即對於任一結點，其可看做是根結點，因此可以直接訪問，訪問完之后，若其左孩子不為空，按相同規則訪問它的左子樹；當訪問其左子樹時，再訪問它的右子樹。因此其處理過程如下：

     對於任一結點P：

     1)訪問結點P，並將結點P入棧;

     2)判斷結點P的左孩子是否為空，若為空，則取棧頂結點並進行出棧操作，並將棧頂結點的右孩子置為當前的結點P，循環至1);若不為空，則將P的左孩子置為當前的結點P;

     3)直到P為NULL並且棧為空，則遍歷結束。

    //非遞歸前序遍歷   
    void pre_order(BTree *root)       
    {  
        stack<BTree*> s;  
        BTree *p = root;       //定義指針p並使樹根指針為它的初值
        //當棧非空或p指針非空時執行循環
        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;  
            }  
        }  
    }

 

二.中序遍歷

    中序遍歷按照“左孩子-根結點-右孩子”的順序進行訪問。

    1.遞歸實現

[cpp] view plain copy
  1. void in_order(BTree* root)    
  2. {    
  3.     //必不可少的條件,遞歸的出口   
  4.      if(root != NULL)   
  5.      {    
  6.         in_order(root->lchild);    
  7.         printf("%2c",root->data);    
  8.         in_order(root->rchild);      
  9.      }    
  10. }   

 

 2.非遞歸實現

       根據中序遍歷的順序，對於任一結點，優先訪問其左孩子，而左孩子結點又可以看做一根結點，然后繼續訪問其左孩子結點，直到遇到左孩子結點為空的結點才進行訪問，然后按相同的規則訪問其右子樹。因此其處理過程如下：

   對於任一結點P，

  1)若其左孩子不為空，則將P入棧並將P的左孩子置為當前的P，然后對當前結點P再進行相同的處理；

  2)若其左孩子為空，則取棧頂元素並進行出棧操作，訪問該棧頂結點，然后將當前的P置為棧頂結點的右孩子；

  3)直到P為NULL並且棧為空則遍歷結束

[cpp] view plain copy
  1. //非遞歸中序遍歷   
  2. void in_order(BTree *root)       
  3. {  
  4.     stack<BTree*> s;  
  5.     BTree *p = root;  
  6.     while (p != NULL || !s.empty()) {  
  7.         while(p != NULL) {              
  8.             s.push(p);  
  9.             p = p->lchild;  
  10.         }  
  11.         if (!s.empty()) {  
  12.             p = s.top();  
  13.             cout<<p->data<<" ";  
  14.             s.pop();  
  15.             p = p->rchild;  
  16.         }  
  17.     }  
  18. }  

 三.后序遍歷

      后序遍歷按照“左孩子-右孩子-根結點”的順序進行訪問。

      1.遞歸實現

[cpp] view plain copy
  1. void post_order(BTree* root)    
  2. {    
  3.     //必不可少的條件,遞歸的出口   
  4.     if(root != NULL)   
  5.     {    
  6.         post_order(root->lchild);    
  7.         post_order(root->rchild);    
  8.         printf("%2c",root->data);    
  9.     }    
  10. }      

 

 2.非遞歸實現

        后序遍歷的非遞歸實現是三種遍歷方式中最難的一種。因為在后序遍歷中，要保證左孩子和右孩子都已被訪問並且左孩子在右孩子前訪問才能訪問根結點，這就為流程的控制帶來了難題。下面介紹兩種思路。

       第一種思路：對於任一結點P，將其入棧，然后沿其左子樹一直往下搜索，直到搜索到沒有左孩子的結點，此時該結點出現在棧頂，但是此時不能將其出棧並訪問， 因此其右孩子還未被訪問。所以接下來按照相同的規則對其右子樹進行相同的處理，當訪問完其右孩子時，該結點又出現在棧頂，此時可以將其出棧並訪問。這樣就 保證了正確的訪問順序。可以看出，在這個過程中，每個結點都兩次出現在棧頂，只有在第二次出現在棧頂時，才能訪問它。因此需要多設置一個變量標識該結點是 否是第一次出現在棧頂。

方 法：要保證根結點在左孩子和右孩子訪問之后才能訪問，因此對於任一結點P，先將其入棧。如果P不存在左孩子和右孩子，則可以直接訪問它；或者P存在左孩子 或者右孩子，但是其左孩子和右孩子都已被訪問過了，則同樣可以直接訪問該結點。若非上述兩種情況，則將P的右孩子和左孩子依次入棧，這樣就保證了每次取棧 頂元素的時候，左孩子在右孩子前面被訪問，左孩子和右孩子都在根結點前面被訪問。

[cpp] view plain copy
  1. //非遞歸后序遍歷  
  2. void post_order(BTree* root)       
  3. {  
  4.     stack<BTree*> s;  
  5.     //當前結點  
  6.     BTree *cur = NULL;     
  7.     //前一次訪問的結點   
  8.     BTree *pre = NULL;        
  9.     s.push(root);  
  10.     while(!s.empty()) {  
  11.         cur = s.top();  
  12.         if( (cur->lchild == NULL && cur->rchild == NULL) ||  
  13.             (pre != NULL && (pre == cur->lchild || pre == cur->rchild)))  
  14.         {  
  15.             //如果當前結點沒有孩子結點或者孩子節點都已被訪問過   
  16.             cout<<cur->data<<" ";                  
  17.             s.pop();  
  18.             pre = cur;   
  19.         } else {  
  20.             if(cur->rchild != NULL)   
  21.                 s.push(cur->rchild);  
  22.             if(cur->lchild!=NULL)     
  23.                 s.push(cur->lchild);  
  24.         }  
  25.     }      
  26. }  


四、層次遍歷

//采用STL中的queue處理

[cpp] view plain copy
  1. #include <queue>  
  2. void layerOrder(BTree *tree)  
  3. {  
  4.     if (tree == NULL)  
  5.         return;  
  6.   
  7.     queue<BTree *> q;  
  8.     q.push(tree);  
  9.       
  10.     BTree *p = NULL;  
  11.     while (!q.empty())  
  12.     {  
  13.         p = q.front();  
  14.         visit(p);          
  15.         q.pop();  
  16.         if (p->lchild != NULL)  
  17.             q.push(p->lchild);  
  18.         if (p->rchild != NULL)  
  19.             q.push(p->rchild);  
  20.     }  
  21. }  


五.二叉樹的其他一些應用

1.求二叉樹的深度

若一棵二叉樹為空，則它的深度為0，否則它的深度等於左子樹和右子樹中的最大深度加1. 設nLeft為左子樹的深度，nRight為右子樹的深度，

則二叉樹的深度為：max(nLeft , nRight)+1.

//樹的深度
int TreeDepth(BTree* root)  
{  
     int nLeft, nRight;  
     if(root == NULL)//必不可少的條件,遞歸的出口  
         return 0;    
     nLeft = TreeDepth(root->lchild);  
     nRight = TreeDepth(root->rchild);  
     return (nLeft > nRight) ? (nLeft + 1):(nRight + 1);  
}

 

2.從二叉樹中查找值為x的結點。若存在，則由x帶回完整值並返回真，否則返回假

該算法類似於前序遍歷，若樹為空則返回false結束遞歸，若樹根結點的值就等於x的值，則把結點值賦給x后返回true結束遞歸，否則先向左子樹查找，若找到則返回true結束遞歸，否則再向右子樹查找，若找到則返回true結束遞歸，若左，右子樹均未找到則返回false結束遞歸。

 

struct BTreeNode
{
	ElemType data;     //結點值域
	BTreeNode *left;   //指向左孩子結點的值域
	BTreeNode *right;  //指向右孩子結點的值域
}

 

bool FindBTree(BTreeNode *BT , ElemType &x)
{
	if(BT == NULL)     //樹為空返回假
		return false;
	if(BT->data == x)  //樹根結點的值等於x則由x帶回結點值並返回真
	{
		x = BT->data;
		return true;
	}
	else
	{
		//向左子樹查找，若成功則繼續返回真
		if(FindBTree(BT->left , x))
			return true;
		//向右子樹查找，若成功則繼續返回真
		if(FindBTree(BT->right , x))
			return true;
		//左，右子樹查找均失敗則返回假
		return false;
	}
}

 

3.統計出二叉樹中等於給定值x的結點個數，結果由函數返回。

此算法也是一個遞歸過程，若樹為空則返回0結束遞歸，若樹根結點的值等於x的值則返回左、右兩棵子樹中等於x結點的個數加1，否則只應返回左、右兩棵子樹中等於x結點的個數。

int CountX(BTreeNode *BT , ElemType &x)
{
	if(BT == NULL)   //空樹返回0
		return 0;
	if(BT->data == x)
		return CountX(BT->left , x)+CountX(BT->right , x) + 1;   //返回1加上兩子樹中的x結點數
	else
		return CountX(BT->left , x)+CountX(BT->right , x);       //返回兩子樹中的x結點數
}

 

4.返回x結點所處的層號，若不存在值為x的結點則返回0.

int NodeLevel(BTreeNode *BT , ElemType &x)
{
	//空樹的層號為0
	if(BT == NULL)
		return 0;
	//根結點的層號為1
	if(BT->data == x)
		return 1;
	else 
	{
		//求出x在左子樹中的層號，返回該層號加1
		int c1 = NodeLevel(BT->left , x);
		if(c1 >= 1)
			return c1+1;
		//求出x在右子樹中的層號，返回該層號加1
		int c2 = NodeLevel(BT->right , x);
		if(c2 >= 1)
			return c2+1;
		//在左、右子樹中都不存在x結點則返回0
		else 
			return 0;
	}
}

 

 5.從二叉樹中找出所有結點的最大值並返回，若為空樹則返回0.

ElemType MaxValue(BTreeNode *BT)
{
	if(BT == NULL)
		return 0;  //空樹返回0

	ElemType k1 , k2;
	k1 = MaxValue(BT->left);  //求出左子樹中的最大值
	k2 = MaxValue(BT->right);  //求出右子樹中的最大值
	if(k1 < k2)
		k1 = k2;   //兩子樹的最大值賦給k1
	if(k1 > BT->data)
		return k1;
	else
		return BT->data;
}

 

 6.求二叉樹中所有結點數。

int BTreeCount(BTreeNode *BT)
{
	if(BT == NULL)
		return 0;
	else
		return BTreeCount(BT->left) + BTreeCount(BT->right) + 1;
}

 

7.求二叉樹中所有葉子結點數

int BTreeLeafCount(BTreeNode *BT)
{
	if(BT == NULL)
		return 0;

	if(BT->left == NULL && BT->right == NULL)
		return 1;
	else
		return BTreeLeafCount(BT->left) + BTreeLeafCount(BT->right);
}

 

 

 

 


免責聲明！

本站轉載的文章為個人學習借鑒使用，本站對版權不負任何法律責任。如果侵犯了您的隱私權益，請聯系本站郵箱yoyou2525@163.com刪除。



猜您在找 二叉樹遍歷(遞歸+非遞歸) 二叉樹的非遞歸遍歷 二叉樹遍歷（非遞歸版） 非遞歸遍歷二叉樹 二叉樹的遞歸遍歷和非遞歸遍歷 二叉樹的遞歸遍歷與非遞歸算法實現 二叉樹的四種遍歷（遞歸與非遞歸） JAVA遞歸、非遞歸遍歷二叉樹（轉） 遍歷二叉樹的遞歸與非遞歸代碼實現 二叉樹的先，中，后序遍歷(遞歸，非遞歸)
 
粵ICP備18138465號   © 2018-2025 CODEPRJ.COM