Chinaunix首页 | 论坛 | 博客

一叶飘然烟雨中

首页　| 　博文目录　| 　关于我

hustfxj

  • 博客访问： 495712
  • 博文数量： 80
  • 博客积分： 0
  • 博客等级： 民兵
  • 技术积分： 1916
  • 用 户 组： 普通用户
  • 注册时间： 2013-07-11 22:01
个人简介

从事实时计算多年，熟悉jstorm/spark/flink/kafka/rocketMq, 热衷于开源，希望在这里和前辈们一起学习与分享，得到长足的进步！邮箱：hustfxj@gmail.com 我的githup地址是：https://github.com/hustfxj。欢迎和大家一起交流探讨问题。

文章分类

全部博文（80）

文章存档

2017年（11）

2015年（3）

2014年（33）

2013年（33）

我的朋友
最近访客
推荐博文
相关博文
二叉树的遍历（递归与非递归）-总结

分类： C/C++

2013-11-01 14:26:04

二叉树的遍历-递归与非递归

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

 

一.前序遍历

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

 

   1.递归实现


点击(此处)折叠或打开

  1. void preOrder1(BinTree *root) //递归前序遍历
  2. {
  3.     if(root!=NULL)
  4.     {
  5.         cout<<root->data<<" ";
  6.         preOrder1(root->lchild);
  7.         preOrder1(root->rchild);
  8.     }
  9. }

2.非递归实现

    

方法一：

根据前序遍历访问的顺序，优先访问根结点，然后再分别访问左孩子和右孩子。即对于任一结点，其可看做是根结点，因此可以直接访问，访问完之后，若其左孩子不为空，按相同规则访问它的左子树；当访问其左子树时，再访问它的右子树。因此其处理过程如下：

     对于任一结点P：

     1)访问结点P，并将结点P入栈;

     2)判断结点P的左孩子是否为空，若为空，则取栈顶结点并进行出栈操作，并将栈顶结点的右孩子置为当前的结点P，循环至1);若不为空，则将P的左孩子置为当前的结点P;

     3)直到P为NULL并且栈为空，则遍历结束。

 

点击(此处)折叠或打开

  1. void preOrder2(BinTree *root) // 非递归前序遍历
  2. {
  3.     stack<BinTree*> s;
  4.     BinTree *p=root;
  5.  
  6.     while(p!=NULL||!s.empty())
  7.     {
  8.         while(p!=NULL)
  9.         {
  10.            cout<<p->data<<" ";
  11.             s.push(p);
  12.             p=p->lchild;
  13.         }
  14.  
  15.         if(!s.empty())
  16.         {
  17.             p=s.top();
  18.             s.pop();
  19.             p=p->rchild;
  20.         }
  21.     }
  22. }

方法二（更加容易理解的方式）：

 

初始：维护一个栈，将根节点压入栈中。

循环：每次从栈顶读出一个节点信息，直接将节点值输出，同时将儿子节点按从右到做的顺序推到栈顶。

分析：跟递归调用的整体思路一样，不同的是，递归调用时是利用运行时系统所维护的程序调用栈来维护顺序，而这个非递归方法是用过自己维护的栈来保存信息。如此节省了调用栈的空间。

 

点击(此处)折叠或打开

  1. public void preOrderTravNoRecur(Node n) {
  2.   Stack<Node> stack = new Stack<Node>();
  3.   stack.add(root);
  4.  
  5.   while (!stack.empty()) {
  6.       Node t = stack.pop();
  7.       System.out.print(t.value + " ");
  8.  
  9.       if (t.rightNode != null)
  10.           stack.add(t.rightNode);
  11.  
  12.       if (t.leftNode != null)
  13.           stack.add(t.leftNode);
  14.   }
  15. }


点击(此处)折叠或打开

  1. public void preOrderTravNoRecur(Node n) {
  2.   Stack<Node> stack = new Stack<Node>();
  3.   stack.add(root);
  4.  
  5.   while (!stack.empty()) {
  6.       Node t = stack.pop();
  7.       System.out.print(t.value + " ");
  8.  
  9.       if (t.rightNode != null)
  10.           stack.add(t.rightNode);
  11.  
  12.       if (t.leftNode != null)
  13.           stack.add(t.leftNode);
  14.   }
  15. }

二.中序遍历

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

    1.递归实现


点击(此处)折叠或打开

  1. void inOrder1(BinTree *root) //递归中序遍历
  2. {
  3.     if(root!=NULL)
  4.     {
  5.         inOrder1(root->lchild);
  6.         cout<<root->data<<" ";
  7.         inOrder1(root->rchild);
  8.     }
  9. }

   2.非递归实现

    根据中序遍历的顺序，对于任一结点，优先访问其左孩子，而左孩子结点又可以看做一根结点，然后继续访问其左孩子结点，直到遇到左孩子结点为空的结点才进行访问，然后按相同的规则访问其右子树。因此其处理过程如下：

   对于任一结点P，

  1)若其左孩子不为空，则将P入栈并将P的左孩子置为当前的P，然后对当前结点P再进行相同的处理；

  2)若其左孩子为空，则取栈顶元素并进行出栈操作，访问该栈顶结点，然后将当前的P置为栈顶结点的右孩子；

  3)直到P为NULL并且栈为空则遍历结束


点击(此处)折叠或打开

  1. void inOrder2(BinTree *root) // 非递归中序遍历
  2. {
  3.     stack<BinTree*> s;
  4.     BinTree *p=root;
  5.  
  6.     while(p!=NULL||!s.empty())
  7.     {
  8.         while(p!=NULL)
  9.         {
  10.             s.push(p);
  11.             p=p->lchild;
  12.         }
  13.  
  14.         if(!s.empty())
  15.         {
  16.             p=s.top();
  17.             cout<<p->data<<" ";
  18.             s.pop();
  19.             p=p->rchild;
  20.         }
  21.     }
  22. }


 

 三.后序遍历

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

      1.递归实现

void postOrder1(BinTree *root)    //递归后序遍历

{

    if(root!=NULL)

    {

        postOrder1(root->lchild);

        postOrder1(root->rchild);

        cout<data<<" ";

    }    

}

 

      

2.非递归实现

后序遍历的非递归实现是三种遍历方式中最难的一种。因为在后序遍历中，要保证左孩子和右孩子都已被访问并且左孩子在右孩子前访问才能访问根结点，这就为流程的控制带来了难题。下面介绍两种思路。

 

第一种思路：

对于任一结点P，将其入栈，然后沿其左子树一直往下搜索，直到搜索到没有左孩子的结点，此时该结点出现在栈顶，但是此时不能将其出栈并访问，因此其右孩子还未被访问。所以接下来按照相同的规则对其右子树进行相同的处理，当访问完其右孩子时，该结点又出现在栈顶，此时可以将其出栈并访问。这样就保证了正确的访问顺序。可以看出，在这个过程中，每个结点都两次出现在栈顶，只有在第二次出现在栈顶时，才能访问它。因此需要多设置一个变量标识该结点是否是第一次出现在栈顶。

 

点击(此处)折叠或打开

  1. void postOrder2(BinTree *root) //非递归后序遍历
  2. {
  3.     stack<BTNode*> s;
  4.     BinTree *p=root;
  5.     BTNode *temp;
  6.  
  7.     while(p!=NULL||!s.empty())
  8.     {
  9.         while(p!=NULL) //沿左子树一直往下搜索，直至出现没有左子树的结点
  10.         {
  11.             BTNode *btn=(BTNode *)malloc(sizeof(BTNode));
  12.             btn->btnode=p;
  13.             btn->isFirst=true;
  14.             s.push(btn);
  15.             p=p->lchild;
  16.         }
  17.  
  18.         if(!s.empty())
  19.         {
  20.             temp=s.top();
  21.             s.pop();
  22.             if(temp->isFirst==true) //表示是第一次出现在栈顶
  23.              {
  24.                 temp->isFirst=false;
  25.                 s.push(temp);
  26.                 p=temp->btnode->rchild;
  27.             }
  28.             else //第二次出现在栈顶
  29.              {
  30.                 cout<<temp->btnode->data<<" ";
  31.                 p=NULL;
  32.             }
  33.         }
  34.     }
  35. }

   

第二种思路（较简洁的代码）：

要保证根结点在左孩子和右孩子访问之后才能访问，因此对于任一结点P，先将其入栈。如果P不存在左孩子和右孩子，则可以直接访问它；或者P存在左孩子或者右孩子，但是其左孩子和右孩子都已被访问过了，则同样可以直接访问该结点。若非上述两种情况，则将P的右孩子和左孩子依次入栈，这样就保证了每次取栈顶元素的时候，左孩子在右孩子前面被访问，左孩子和右孩子都在根结点前面被访问。

void postOrder3(BinTree * root)      //非递归后序遍历

{

    stack < BinTree *> s;

    BinTree * cur;                       //当前结点  

    BinTree * pre = NULL;                  //前一次访问的结点  

    s.push(root);

 

     while ( ! s.empty())

    {

        cur = s.top();

 

//如果当前结点没有孩子结点或者孩子节点都已被访问过 

         if ((cur -> lchild == NULL && cur -> rchild == NULL) ||

           (pre != NULL && (pre == cur -> lchild || pre == cur -> rchild)))

        {

            cout << cur -> data <<" " ;    

            s.pop();

            pre = cur; 

        }

         else

        {

             if (cur -> rchild != NULL)

                s.push(cur -> rchild);

             if (cur -> lchild != NULL)    

                s.push(cur -> lchild);

        }

    }    

}

 

四、层次遍历

 

  • 无法使用递归方法

层序遍历不同于其他的遍历。可以通过反证法证明：

如果能实现对 A 节点的层序递归，在对 A 节点处理的过程中，应该递归的对两个儿子 B 和 C 分别调用了层序遍历。在这种情况下，我们无法让 B 和 C 的同一个层级的儿子在集中的时间中被遍历到，换言之，B 的第一层儿子在对 B 的调用中被遍历，而 C 的第一层儿子，则在对 C 的调用中遍历，这是分离开的。不成立，得证。

 

 

  • 非递归方法：

分析：此方法类似于前序遍历的非递归方法的第一种。用一个栈维护信息。


点击(此处)折叠或打开

  1. public void levelOrderTrav(Node n) {
  2.   System.out.print("Level OrderTrav: ");
  3.   
  4.   Queue<Node> q = new LinkedList<Node>();
  5.   q.add(n);
  6.   while (q.size() != 0) {
  7.       n = q.poll();
  8.       System.out.print(" " + n.value);
  9.       if (n.leftNode != null)
  10.           q.add(n.leftNode);
  11.       if (n.rightNode != null)
  12.           q.add(n.rightNode);
  13.   }
  14. }

五、整个程序完整的代码


点击(此处)折叠或打开

  1. /*二叉树的遍历* 2011.8.25*/
  2. #include <iostream>
  3. #include<string.h>
  4. #include<stack>
  5. using namespace std;
  6. typedef struct node
  7. {
  8.     char data;
  9.     struct node *lchild,*rchild;
  10. }BinTree;
  11. typedef struct node1
  12. {
  13.     BinTree *btnode;
  14.     bool isFirst;
  15. }BTNode;
  16.  
  17. void creatBinTree(char *s,BinTree *&root) //创建二叉树，s为形如A(B,C(D,E))形式的字符串
  18. {
  19.     int i;
  20.     bool isRight=false;
  21.     stack<BinTree*> s1; //存放结点
  22.     stack<char> s2; //存放分隔符
  23.     BinTree *p,*temp;
  24.     root->data=s[0];
  25.     root->lchild=NULL;
  26.     root->rchild=NULL;
  27.     s1.push(root);
  28.     i=1;
  29.     while(i<strlen(s))
  30.     {
  31.         if(s[i]=='(')
  32.         {
  33.             s2.push(s[i]);
  34.             isRight=false;
  35.         }
  36.         else if(s[i]==',')
  37.         {
  38.             isRight=true;
  39.         }
  40.         else if(s[i]==')')
  41.         {
  42.             s1.pop();
  43.             s2.pop();
  44.         }
  45.         else if(isalpha(s[i]))
  46.         {
  47.             p=(BinTree *)malloc(sizeof(BinTree));
  48.             p->data=s[i];
  49.             p->lchild=NULL;
  50.             p->rchild=NULL;
  51.             temp=s1.top();
  52.             if(isRight==true)
  53.             {
  54.                 temp->rchild=p;
  55.                 cout<<temp->data<<"的右孩子是"<<s[i]<<endl;
  56.             }
  57.             else
  58.             {
  59.                 temp->lchild=p;
  60.                 cout<<temp->data<<"的左孩子是"<<s[i]<<endl;
  61.             }
  62.             if(s[i+1]=='(')
  63.                 s1.push(p);
  64.         }
  65.         i++;
  66.     }
  67. }
  68. void display(BinTree *root) //显示树形结构
  69. {
  70.     if(root!=NULL)
  71.     {
  72.         cout<<root->data;
  73.         if(root->lchild!=NULL)
  74.         {
  75.             cout<<'(';
  76.             display(root->lchild);
  77.         }
  78.         if(root->rchild!=NULL)
  79.         {
  80.             cout<<',';
  81.             display(root->rchild);
  82.             cout<<')';
  83.         }
  84.     }
  85. }
  86. void preOrder1(BinTree *root) //递归前序遍历
  87. {
  88.     if(root!=NULL)
  89.     {
  90.         cout<<root->data<<" ";
  91.         preOrder1(root->lchild);
  92.         preOrder1(root->rchild);
  93.     }
  94. }
  95. void inOrder1(BinTree *root) //递归中序遍历
  96. {
  97.     if(root!=NULL)
  98.     {
  99.         inOrder1(root->lchild);
  100.         cout<<root->data<<" ";
  101.         inOrder1(root->rchild);
  102.     }
  103. }
  104. void postOrder1(BinTree *root) //递归后序遍历
  105. {
  106.     if(root!=NULL)
  107.     {
  108.         postOrder1(root->lchild);
  109.         postOrder1(root->rchild);
  110.         cout<<root->data<<" ";
  111.     }
  112. }
  113. void preOrder2(BinTree *root) //非递归前序遍历
  114. {
  115.     stack<BinTree*> s;
  116.     BinTree *p=root;
  117.     while(p!=NULL||!s.empty())
  118.     {
  119.         while(p!=NULL)
  120.         {
  121.             cout<<p->data<<" ";
  122.             s.push(p);
  123.             p=p->lchild;
  124.         }
  125.         if(!s.empty())
  126.         {
  127.             p=s.top();
  128.             s.pop();
  129.             p=p->rchild;
  130.         }
  131.     }
  132. }
  133. void inOrder2(BinTree *root) //非递归中序遍历
  134. {
  135.     stack<BinTree*> s;
  136.     BinTree *p=root;
  137.     while(p!=NULL||!s.empty())
  138.     {
  139.         while(p!=NULL)
  140.         {
  141.             s.push(p);
  142.             p=p->lchild;
  143.         }
  144.         if(!s.empty())
  145.         {
  146.             p=s.top();
  147.             cout<<p->data<<" ";
  148.             s.pop();
  149.             p=p->rchild;
  150.         }
  151.     }
  152. }
  153. void postOrder2(BinTree *root) //非递归后序遍历
  154. {
  155.     stack<BTNode*> s;
  156.     BinTree *p=root;
  157.     BTNode *temp;
  158.     while(p!=NULL||!s.empty())
  159.     {
  160.         while(p!=NULL) //沿左子树一直往下搜索，直至出现没有左子树的结点
  161.          {
  162.             BTNode *btn=(BTNode *)malloc(sizeof(BTNode));
  163.             btn->btnode=p;
  164.             btn->isFirst=true;
  165.             s.push(btn);
  166.             p=p->lchild;
  167.         }
  168.         if(!s.empty())
  169.         {
  170.             temp=s.top();
  171.             s.pop();
  172.             if(temp->isFirst==true) //表示是第一次出现在栈顶
  173.              {
  174.                 temp->isFirst=false;
  175.                 s.push(temp);
  176.                 p=temp->btnode->rchild;
  177.             }
  178.             else //第二次出现在栈顶
  179.              {
  180.                 cout<<temp->btnode->data<<" ";
  181.                 p=NULL;
  182.             }
  183.         }
  184.     }
  185. }
  186. void postOrder3(BinTree *root) //非递归后序遍历
  187. {
  188.     stack<BinTree*> s;
  189.     BinTree *cur; //当前结点
  190.     BinTree *pre=NULL; //前一次访问的结点
  191.     s.push(root);
  192.     while(!s.empty())
  193.     {
  194.         cur=s.top();
  195.         if((cur->lchild==NULL&&cur->rchild==NULL)||
  196.            (pre!=NULL&&(pre==cur->lchild||pre==cur->rchild)))
  197.         {
  198.             cout<<cur->data<<" "; //如果当前结点没有孩子结点或者孩子节点都已被访问过
  199.               s.pop();
  200.             pre=cur;
  201.         }
  202.         else
  203.         {
  204.             if(cur->rchild!=NULL)
  205.                 s.push(cur->rchild);
  206.             if(cur->lchild!=NULL)
  207.                 s.push(cur->lchild);
  208.         }
  209.     }
  210. }
  211.  
  212. int main(int argc, char *argv[])
  213. {
  214.     char s[100];
  215.     while(scanf("%s",s)==1)
  216.     {
  217.         BinTree *root=(BinTree *)malloc(sizeof(BinTree));
  218.         creatBinTree(s,root);
  219.         display(root);
  220.         cout<<endl;
  221.         preOrder2(root);
  222.         cout<<endl;
  223.         inOrder2(root);
  224.         cout<<endl;
  225.         postOrder2(root);
  226.         cout<<endl;
  227.         postOrder3(root);
  228.         cout<<endl;
  229.     }
  230.     return 0;
  231. }

 此外参考：

二叉树类型笔试面试题大总结（含代码）

http://blog.csdn.net/xiajun07061225/article/details/12760493

阅读(1073) | 评论(0) | 转发(0) |
0

上一篇：二叉搜索树的C++实现

下一篇：与函数指针功能差不多的std::tr1::function对象

给主人留下些什么吧！~~
关于我们 | 关于IT168 | 联系方式 | 广告合作 | 法律声明 | 免费注册

Copyright 2001-2010 ChinaUnix.net All Rights Reserved 北京皓辰网域网络信息技术有限公司. 版权所有

感谢所有关心和支持过ChinaUnix的朋友们

16024965号-6