【树】二叉树遍历算法基于栈的递归消除

二叉树的遍历问题递归的问题无法直接转换成循环，所以需要采用工作栈消除递归。工作栈提供一种控制结构，当递归算法进层时需要将信息保留；当递归算法出层时需要从栈区退出上层信息。

递归进层的三件事

1. 保存本层参数，返回地址
2. .传递参数，分配局部数据空间
3. 控制转移

递归退层的三件事

1. 恢复上层
2. 传递结果
3. 转断点执行

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

初步

【算法思想】 （1） 针对左递归，写出递归进层的三件事。 （2） 接着写出左递归返回时应执行的语句：访问根结点。 （3） 接着针对右递归，写出递归进层的三件事。 （4） 针对递归退层，写出递归退层的三件事（左、右递归公用）。 【算法描述】

void inorder(BiTree root);
{
    int top = 0;
    p = root;
L1:
    if (p != NULL) /* 遍历左子树 */
    {
        top = top + 2;
        if (top > m)
            return;     /*栈满溢出*/
        s[top - 1] = p; /* 本层参数进栈 */
        s[top] = L2;    /* 返回地址进栈 */
        p = p->LChild;  /* 给下层参数赋值 */
        goto L1;        /* 转向开始 */
    L2:
        Visit(p->data); /* 访问根 */
        top = top + 2;
        if (top > m)
            return; /*栈满溢出处理*/
        ;
        s[top - 1] = p; /* 遍历右子树 */
        s[top] = L3;
        p = p->RChild;
        goto L1;
    }
L3:
    if (top != 0)
    {
        addr = s[top];
        p = s[top - 1]; /* 取出返回地址 */
        top = top - 2;  /* 退出本层参数 */
        goto addr;
    }
}

可看到，直接按定义得到的上述算法结构并不好，为使程序合理组织，需去掉goto 语句, 用循环句代替 if 与 goto, 此时返回断点已无保留的必要，栈区只需保留本层参数即可。整理后的算法框图如下图：

直接实现桟操作

中序遍历非递归算法需要设置一个堆栈，用以保留结点指针，以便在遍历完某个结点的左子树后，由该结点指针找到该结点的右子树。
【算法思想】
从根结点开始，只要当前结点存在，或者栈不空，则重复下面操作：
（1） 从当前结点开始，进栈并走左子树，直到左子树为空。
（2） 退栈并访问。
（3） 走右子树。
【算法描述】

/*s[m] 表示栈，top 表示栈顶指针*/
void inorder(BiTree root) /* 中序遍历二叉树，root 为二叉树的根结点 */
{
    top = 0;
    p = root;
    do
    {
        while (p != NULL)
        {
            if (top > m)
                return;
            top = top + 1;
            s[top] = p;
            p = p->LChild;
        } /* 遍历左子树 */
        if (top != 0)
        {
            p = s[top];
            top = top - 1;
            Visit(p->data); /* 访问根结点 */
            p = p->RChild;
        } /* 遍历右子树 */
    } while (p != NULL || top != 0);
}

调用栈操作的函数

【算法思想】从根结点开始，只要当前结点存在，或者栈不空，则重复下面操作：
（1） 如果当前结点存在，则进栈并走左子树。
（2） 否则退栈并访问，然后走右子树。
【算法描述】

void InOrder（BiTree root） /* 中序遍历二叉树的非递归算法 */
{
    InitStack(&S);
    p = root;
    while (p != NULL || !IsEmpty(S))
    {
        if (p != NULL) /* 根指针进栈，遍历左子树 */
        {
            Push(&S, p);
            p = p->LChild;
        }
        else
        { /*根指针退栈，访问根结点，遍历右子树*/
            Pop(&S, &p);
            Visit(p->data);
            p = p->RChild;
        }
    }
}

递归算法的时间复杂度分析：对有 n 个结点二叉树，该算法每循环一次，p 指向一个结点或空（无左孩子或无右孩子的结点的空链域），因此指向空的次数为n+1，n 为结点个数，故循环次数为 n+(n+1)=2n+1,因此算法的复杂度为 O(n)。
递归算法的空间复杂度分析：所需栈的空间最多等于二叉树深度 K 乘以每个结点所需空间数，记作 O(K)。表面上看，递归算法好象并没有使用栈，实际上递归算法的执行需要反复多次的自己调用自己。每调用一次，系统内部都有系统运行栈区在支持，这是隐含的栈，需要保留本层参数、临时变量与返回地址等。随着函数递归调用，运行栈继续增长，直到函数执行完，才彻底释放占用的栈空间。因此递归算法比非递归算法占用的空间更多。

后序遍历二叉树的非递归算法

后序遍历的非递归算法比较复杂。由于后序遍历是 LRD，要求左、右子树都访问完后，最后访问根结点。如何判断当前栈顶结点的左、右子树都已访问过？解决的方案有多种，采用的方法是：判断刚访问过的结点 q 是不是当前栈顶结点 p 的右孩子。
判别是否应该访问当前栈顶结点 p 时，有两种情况：
（1）p 无右孩子，此时应该访问根结点；
（2）如 p 的右孩子是刚被访问过的结点 q（表明 p 的右子树已遍历过），此时也应该访问根结点。除这两种情况外，均不应访问根，而是要继续进入右子树中。
因此，算法采用了记录刚访问结点的方法，以便在遍历过程中利用前驱 q 与当前结点 p 的关系做判别。
【算法思想】从根结点开始，只要当前结点存在，或者栈不空，则重复下面操作：
（1） 从当前结点开始，进栈并走左子树，直到左子树为空；
（2） 如果栈顶结点的右子树为空，或者栈顶结点的右子孩子为刚访问过的结点，则退栈并访问，然后将当前结点指针置为空；
（3） 否则，走右子树。
【算法描述】

void PostOrder（BiTree root）
{
    BiTNode *p, *q；
                    Stack S;
    q = NULL;
    p = root;
    InitStack(&S);
    while (p != NULL || !IsEmpty(S))
    {
        while (p != NULL)
        {
            Push(&S, p);
            p = p->LChild;
        } /*遍历左子树*/
        if (!IsEmpty(S))
        {
            GetTop(&S, &p);
            if ((p->RChild == NULL) || (p->RChild == q)) /* 无右孩子，或右孩子已遍历过 */
            {
                visit(p->data); /* 访问根结点*/
                q = p;          /*保存到 q，为下一次已处理结点前驱 */
                Pop(&S, &p);
                p = NULL;
            }
            else
                p = p->RChild;
        }
    }
}