二叉树的遍历——递归和非递归

2021-11-08 21:29:01

 二 叉树是一种非常重要的数据结构，很多其它数据结构都是基于二叉树的基础演变而来的。对于二叉树，有前序、中序以及后序三种遍历方法。因为树的定义本身就是 递归定义，因此采用递归的方法去实现树的三种遍历不仅容易理解而且代码很简洁。而对于树的遍历若采用非递归的方法，就要采用栈去模拟实现。在三种遍历中， 前序和中序遍历的非递归算法都很容易实现，非递归后序遍历实现起来相对来说要难一点。

一.前序遍历

   前序遍历按照“根结点-左孩子-右孩子”的顺序进行访问。

  1.递归实现

[cpp] view plaincopy
  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并且栈为空，则遍历结束。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
//非递归前序遍历  
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 plaincopy
  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 plaincopy
  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 plaincopy
  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 plaincopy
  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 plaincopy
  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.

1
2
3
4
5
6
7
8
9
10
//树的深度
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;  //指向右孩子结点的值域
}

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
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结点的个数。

1
2
3
4
5
6
7
8
9
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.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
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.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
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.求二叉树中所有结点数。

1
2
3
4
5
6
7
int BTreeCount(BTreeNode *BT)
{
    if(BT == NULL)
        return 0;
    else
        return BTreeCount(BT->left) + BTreeCount(BT->right) + 1;
}

 

7.求二叉树中所有叶子结点数

1
2
3
4
5
6
7
8
9
10
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);
}

 

 




本文转自夏雪冬日博客园博客，原文链接：http://www.cnblogs.com/heyonggang/p/3399464.html，如需转载请自行联系原作者

上一篇：我的Android进阶之旅------>介绍一款集录制与剪辑为一体的屏幕GIF 动画制作工具 GifCam


下一篇：SAP Fiori Elements里Smart Link工作原理介绍