C语言实现二叉树的递归遍历与非递归遍历

 本文实现了对二叉树的递归遍历和非递归遍历,当然还包括了一些栈操作。

          二叉树的遍历本质上其实就是入栈出栈的问题,递归算法简单且容易理解,但是效率始终是个问题。非递归算法可以清楚的知道每步实现的细节,但是乍一看不想递归算法那么好理解,各有各的好处吧。接下来根据下图讲讲树的遍历。



          1、先序遍历:先序遍历是先输出根节点,再输出左子树,最后输出右子树。上图的先序遍历结果就是:ABCDEF

          2、中序遍历:中序遍历是先输出左子树,再输出根节点,最后输出右子树。上图的中序遍历结果就是:CBDAEF

          3、后序遍历:后序遍历是先输出左子树,再输出右子树,最后输出根节点。上图的后序遍历结果就是:CDBFEA

         其中,后序遍历的非递归算法是最复杂的,我用了一个标识符isOut来表明是否需要弹出打印。因为只有当节点的左右子树都打印后该节点 才能弹出栈打印,所以标识isOut为1时打印,isOut初始值为0,这主要是为了处理非叶子节点。由后序遍历的原理决定,左右子树都被打印该节点才能打印,所以该节点肯定会被访问2次,第一次的时候不要打印,第二次打印完右子树的时候打印。叶子节点打印完后将isOut置为1。(纯粹是自己想的,应该还有逻辑更简单的算法)

         isOut处理具体如下:

  •  所有节点入栈的时候初始化为0;
  •  叶子节点打印输出后将isOut置为1;
  • 非叶子节点分两种情况。如果存在左子树,则输出左子树后将isOut置为1,此时指针已获得其右子树节点;如果不存在左子树,则将isOut置为1,此时指针已获得其右子树节点;在代码中分别体现在                                                                                                                                                                                                                                                     if ( (p->lchild) && (p->lchild->isOut == 1) )                                                                                                                                                                                                                            {//如果存在左子树,并且左子树已经遍历完,则说明该节点已经入栈,不用再次Push,直接走向右子树          
           p->isOut = 1;
           p = p->rchild;   
     }和                                                                                                                                                                                                                                                                                                 if (!StackEmpty(s))
      {
            GetTop(s,p);
            if ( p->lchild == NULL )
            p->isOut = 1; //右子树已输出,将父节点isOut置1
       };
  • 遇到isOut=1的时候,说明左右子树都已输出,所以该节点也出栈打印出来。

         以中序遍历为例,看看栈的内容是如何变化的:

         

          具体的代码实现如下:

      

[cpp]  view plain  copy
  1. #include<stdio.h>  
  2. #include<stdlib.h>  
  3.   
  4. #define STACKINITSIZE 100  
  5. #define STACKINCREASESIZE 20  
  6.   
  7. typedef char ElemType;  
  8. //树结构  
  9. typedef struct tree  
  10. {  
  11.     ElemType data;  
  12.     struct tree * lchild;  
  13.     struct tree * rchild;  
  14.     unsigned int isOut;   //专为后序遍历设置的,0为不需要被输出,1为需要被输出  
  15. }TreeNode,*Tree;  
  16.   
  17. //栈结构  
  18. typedef struct stack  
  19. {  
  20.     Tree * base;  
  21.     Tree * top;  
  22.     int stacksize;  
  23. }Sqstack;  
  24.   
  25.   
  26. /*****************栈的操作声明********************/  
  27.   
  28. //初始化栈  
  29. void InitStack( Sqstack &s );  
  30. //元素入栈  
  31. void Push( Sqstack &s, Tree e );  
  32. //获得栈顶元素  
  33. void GetTop( Sqstack s, Tree &e );  
  34. //弹出栈顶元素  
  35. void Pop( Sqstack &s, Tree &e );  
  36. //判断栈是否为空,为空返回1,否则返回0  
  37. int StackEmpty( Sqstack s );  
  38.   
  39. /*****************栈的操作声明********************/  
  40.   
  41.   
  42. /*****************树的操作声明********************/  
  43. //创建树,以先序序列建立树  
  44. void CreateTree(Tree &t);  
  45. //递归先序遍历  
  46. void PreOrder(Tree t);  
  47. //非递归先序遍历  
  48. void PreOrder1(Tree t);  
  49. //递归中序遍历  
  50. void InOrder(Tree t);  
  51. //非递归中序遍历  
  52. void InOrder1(Tree t);  
  53. //递归后序遍历  
  54. void PostOrder(Tree t);  
  55. //非递归后序遍历  
  56. void PostOrder1(Tree t);  
  57. /*****************树的操作声明********************/  
  58.   
  59. int main()  
  60. {  
  61.     Tree T;  
  62.     printf("\n按先序序列输入结点序列,'#'代表空:");  
  63.     CreateTree(T);  
  64.   
  65.     printf("\n非递归先序遍历的结果:");  
  66.     PreOrder1(T);  
  67.     printf("\n递归先序遍历的结果:  ");  
  68.     PreOrder(T);  
  69.   
  70.     printf("\n非递归中序遍历的结果:");  
  71.     InOrder1(T);  
  72.     printf("\n递归中序遍历的结果:  ");  
  73.     InOrder(T);  
  74.   
  75.     printf("\n非递归后序遍历的结果:");  
  76.     PostOrder1(T);  
  77.     printf("\n递归后序遍历的结果:  ");  
  78.     PostOrder(T);  
  79.     printf("\n");  
  80.   
  81. }  
  82.   
  83.   
  84. /*****************栈的操作定义********************/  
  85.   
  86. //初始化栈  
  87. void InitStack( Sqstack &s )  
  88. {  
  89.     s.base = (Tree *)malloc(STACKINITSIZE*sizeof(Tree));  
  90.     if ( !s.base )  
  91.     {  
  92.     printf("InitStack内存分配出错\n");  
  93.     }      
  94.     s.top = s.base;  
  95.     s.stacksize = STACKINITSIZE;  
  96. }  
  97.   
  98. //元素入栈  
  99. void Push( Sqstack &s, Tree e )  
  100. {  
  101.     if ( s.top - s.base >= s.stacksize )  
  102.     {  
  103.     s.base = (Tree *)realloc(s.base,(s.stacksize+STACKINCREASESIZE)*sizeof(Tree));  
  104.     if ( !s.base )  
  105.         {  
  106.         printf("Push内存分配出错\n");  
  107.         return ;  
  108.         }  
  109.       
  110.      s.top = s.base + s.stacksize;  
  111.     s.stacksize += STACKINCREASESIZE;  
  112.     }  
  113.     e->isOut = 0;  
  114.     *s.top++ = e;  
  115. }  
  116.   
  117. //获得栈顶元素  
  118. void GetTop( Sqstack s, Tree &e )  
  119. {  
  120.     e = *(s.top - 1);  
  121. }  
  122.   
  123. //弹出栈顶元素  
  124. void Pop( Sqstack &s, Tree &e )  
  125. {  
  126.     if ( s.top == s.base )  
  127.     {  
  128.     printf("栈为空\n");  
  129.     return ;  
  130.     }  
  131.     e = *(--s.top);  
  132. }  
  133.   
  134. //判断栈是否为空,为空返回1,否则返回0  
  135. int StackEmpty( Sqstack s )  
  136. {  
  137.     if ( s.top == s.base )  
  138.     return 1;  
  139.     return 0;  
  140. }  
  141.   
  142. /*****************栈的操作定义********************/  
  143.   
  144.   
  145.   
  146. /*****************树的操作定义********************/  
  147. //创建树,以先序序列建立树  
  148. void CreateTree(Tree &t)  
  149. {  
  150.     char ch;  
  151.     scanf("%c",&ch);  
  152.     if ( ch == '#' )  
  153.     t = NULL;  
  154.     else  
  155.     {  
  156.     t = (Tree)malloc(sizeof(TreeNode));  
  157.         if ( !t )  
  158.     {  
  159.         printf("分配内存出错!");  
  160.         return ;  
  161.     }  
  162.     t->data = ch;  
  163.     CreateTree(t->lchild);  
  164.     CreateTree(t->rchild);  
  165.     }  
  166. }  
  167.   
  168.   
  169. //递归先序遍历  
  170. void PreOrder(Tree t)  
  171. {  
  172.     if ( t )  
  173.     {  
  174.     printf("%c",t->data);  
  175.     PreOrder(t->lchild);  
  176.     PreOrder(t->rchild);  
  177.     }  
  178. }  
  179.   
  180. //非递归先序遍历  
  181. void PreOrder1(Tree t)  
  182. {  
  183.     Tree p = t;  
  184.     Sqstack s;  
  185.     InitStack(s);  
  186.   
  187.     while ( p || !StackEmpty(s) )  
  188.     {  
  189.     if ( p )  
  190.     {  
  191.         printf("%c",p->data);  
  192.         Push(s,p);  
  193.         p = p->lchild;      
  194.     }  
  195.     else  
  196.     {  
  197.         Pop(s,p);   
  198.         p = p->rchild;  
  199.     }  
  200.     }  
  201.   
  202. }  
  203.   
  204.   
  205. //递归中序遍历  
  206. void InOrder(Tree t)  
  207. {  
  208.     if ( t )  
  209.     {  
  210.     InOrder(t->lchild);  
  211.     printf("%c",t->data);  
  212.     InOrder(t->rchild);  
  213.     }  
  214. }  
  215.   
  216.   
  217. //非递归中序遍历  
  218. void InOrder1(Tree t)  
  219. {  
  220.     Tree p = t;  
  221.     Sqstack s;  
  222.     InitStack(s);    
  223.       
  224.     while ( p || !StackEmpty(s) )  
  225.     {  
  226.     if ( p )  
  227.         {  
  228.         Push(s,p);  
  229.         p = p->lchild;  
  230.     }      
  231.     else  
  232.     {  
  233.         Pop(s,p);  
  234.         printf("%c",p->data);  
  235.         p = p->rchild;  
  236.     }   
  237.     }  
  238. }  
  239.   
  240. //递归后序遍历  
  241. void PostOrder(Tree t)  
  242. {  
  243.     if ( t )  
  244.     {  
  245.     PostOrder(t->lchild);  
  246.      PostOrder(t->rchild);  
  247.     printf("%c",t->data);  
  248.     }  
  249. }  
  250.   
  251.   
  252. //非递归后序遍历  
  253. void PostOrder1(Tree t)  
  254. {  
  255.     t->isOut = 0;  
  256.     Tree p = t;  
  257.     Sqstack s;  
  258.     InitStack(s);   
  259.   
  260.     while ( p || !StackEmpty(s) )  
  261.     {  
  262.     if ( p )  
  263.         {  
  264.         if ( p->isOut )  
  265.             {//左右子树都已输出,则该节点也输出          
  266.             Pop(s,p);  
  267.             printf("%c",p->data);  
  268.         if (!StackEmpty(s))  
  269.                 GetTop(s,p); //得到弹出节点元素的父节点  
  270.             else  
  271.             p = NULL;  
  272.         }  
  273.         else  
  274.         {      
  275.             if ( (p->lchild) && (p->lchild->isOut == 1) )  
  276.             {//如果存在左子树,并且左子树已经遍历完,则说明该节点已经入栈,不用再次Push,直接走向右子树            
  277.             p->isOut = 1;  
  278.             p = p->rchild;     
  279.               }  
  280.             else  
  281.             {  
  282.             Push(s,p);  
  283.             p = p->lchild;  
  284.             }            
  285.         }  
  286.         }  
  287.         else  
  288.         {  
  289.         if (!StackEmpty(s))  
  290.             GetTop(s,p);   
  291.         else  
  292.         p = NULL;  
  293.   
  294.         if ( p->rchild )  
  295.         {  
  296.             p = p->rchild;  
  297.         }  
  298.         else  
  299.         {  
  300.            Pop(s,p);  
  301.             printf("%c",p->data);  
  302.             p->isOut = 1;  
  303.             if (!StackEmpty(s))  
  304.             {  
  305.             GetTop(s,p);  
  306.             if ( p->lchild == NULL )  
  307.                 p->isOut = 1; //右子树已输出,将父节点isOut置1  
  308.         }  
  309.             else  
  310.             p = NULL;  
  311.         }  
  312.           
  313.         }  
  314.     }  
  315.       
  316. }  
         运行结果如下:


评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值