二叉树递归遍历与非递归遍历的栈空间使用

  二叉树是常见的非线性数据结构类型。其基本储存结构如下：

  struct nodetype{
   char info,
   struct nodetype *lchild,
   struct nodetype *rchild;

  }nodetype *nodetype;

典型的二叉树遍历算法：
  <1>先序遍历

  <2>中序遍历

  <3>后序遍历

在此，我们以中序遍历为例，讨论递归与非递归遍历中栈空间的使用情况。

递归的二叉树中序遍历算法：

 void InOrder(BiTree T){  
    if(T != NULL){  
        //访问左子结点  
        InOrder(T->lchild);  
        //访问根节点  
        Visit(T);  
        //访问右子结点  
        InOrder(T->rchild);  
    }  
}  

非递归的二叉树中序遍历：

void InOrder(BiTree T){  
    stack<BiTree> stack;  //init stack
    
    BiTree pt = T;  
    
    while(pt || !stack.empty()){  
        if(pt != NULL){  
            //存入栈中  
            stack.push(pt);  
            //遍历左子树  
            pt = pt->lchild;  
        }  
        else{  
             
            pt = stack.top();  
            printf("%c ",pt->data);  
            stack.pop();  
            //访问右子树  
            pt = pt->rchild;  
        }  
    } 
}  

我们以如下图中二叉树为例：

访问元素                         栈内容                              说明

递归中序算法：

 1，访问根节点             1                                       1入栈
  2，访问左子树            1,2                                    2入栈
  3，                              1,2,3                                 3,入栈
  4，                              1,2,3,4                              4入栈
  5，访问4                    1,2,3                                 4左子树为空，4出栈
                                    1,2,3,4                               访问4的右子树，4第二次入栈
                                    1,2,3                                  由于4的右子树为空，返回，4第二次出栈
  6，访问3                   1,2                                     3出栈
                                   1,2,3                                   访问3 的右孩子，3第二次入栈
                                   1,2,3,5                                5入栈
  7，访问5                   1,2,3                                  由于5 左子树为空，5出栈
                                    1,2,3,4                               访问5 的右子树，5第二次入栈
                                    1,2,3                                  由于5的右子树为空，5第二次出栈
                                    1,2                                     3第二次出栈

非递归中序算法：
  1，访问根节点          1                                     1入栈
  2，访问左子树          1,2                                   2入栈
  3，                            1,2,3                               3入栈
  4，                            1,2,3,4                            4入栈
  5，访问4                  1,2,3                                4左子树为空，4出栈
  6，访问3                  1,2                                   由于4的左子树为空，3出栈
                                    1,2,5                              5入栈
  7，访问5                  1,2                                   5的左子树为空，5出栈

从两个过程可以看出，非递归中序算法每个节点只入栈与出栈一次，栈空间使用量比递归算法少。

可以看出，程序设计时虽然递归算法比较常用，但一旦递归的量大时将是对栈空间的一大浪费，所以对每一个问题我们也该考虑非递归算法的解决思路。