二叉树的先序、中序、后序遍历算法【递归、非递归】

理论分析

遍历，就是按照某种次序把所有的节点都访问一遍
二叉树的可能的情况：

1. 空二叉树
2. 根节点+左子树
3. 根节点+右子树
4. 根节点+左右子树

如果是空二叉树，无序遍历；如果是非空二叉树，可以按照先序、中序、后序遍历

代码实现

typedef struct BiTNode{
    ElemType data;
    struct BiTNode *lchild,*rchild;
}BiTNode,*BiTree;

先序遍历

void PreOrder(BiTree T){
    if(T!=NULL){
        visit(T);//访问二叉树或其子树的根节点的相关操作
        PreOrder(T->lchild);//递归遍历左子树
        PreOrder(T->rchild);//递归遍历右子树
    }
}

中序遍历

void PreOrder(BiTree T){
    if(T!=NULL){
        InOrder(T->lchild);//递归遍历左子树
        visit(T);//访问二叉树或其子树的根节点的相关操作
        InOrder(T->rchild);//递归遍历右子树
    }
}

后序遍历

void PreOrder(BiTree T){
    if(T!=NULL){
        PostOrder(T->lchild);//递归遍历左子树
        PostOrder(T->rchild);//递归遍历右子树
        visit(T);//访问二叉树或其子树的根节点的相关操作
    }
}

非递归遍历以及与递归版本的比较理解

在二叉树的遍历中，递归和栈的思想是紧密相关的。递归本质上就是一个隐式的栈结构，它利用函数调用栈来保存中间状态。而栈则是一个显式的数据结构，可以手动控制入栈和出栈来模拟递归过程。
下面我将用栈的思想来解释二叉树的三种递归遍历：先序遍历、中序遍历和后序遍历。

1. 先序遍历

递归版本：

void PreOrder(BiTree T){
    if(T!=NULL){
        visit(T);
        PreOrder(T->lchild);
        PreOrder(T->rchild);
    }
}

栈版本：

void PreOrderWithStack(BiTree T){
    Stack S;
    InitStack(S);
    if(T!=NULL){
        Push(S, T);
    }
    while(!IsEmpty(S)){
        BiTree T = Pop(S);
        visit(T);
        if(T->rchild!=NULL){
            Push(S, T->rchild);
        }
        if(T->lchild!=NULL){
            Push(S, T->lchild);
        }
    }
}

解释：

• 递归版本中，先访问根节点，然后递归地访问左子树和右子树。
• 在栈版本中，我们首先将根节点入栈。然后，在循环中，我们不断从栈中弹出节点并访问它。接着，我们将其右子树和左子树（注意顺序）入栈。由于栈是后入先出的数据结构，因此左子树会先于右子树被处理，这与递归版本的行为是一致的。

2. 中序遍历

递归版本：

void InOrder(BiTree T){
    if(T!=NULL){
        InOrder(T->lchild);
        visit(T);
        InOrder(T->rchild);
    }
}

栈版本：

void InOrderWithStack(BiTree T){
    Stack S;
    InitStack(S);
    BiTree prev = NULL;
    while(T!=NULL || !IsEmpty(S)){
        while(T!=NULL){
            Push(S, T);
            T = T->lchild;
        }
        T = Pop(S);
        if(prev==NULL || prev->rchild==T){
            visit(T);
            prev = T;
            T = NULL;
        } else {
            T = T->rchild;
        }
    }
}

解释：

• 递归版本中，先递归地访问左子树，然后访问根节点，最后递归地访问右子树。
• 在栈版本中，我们模拟了这个过程。首先，我们不断将当前节点的左子树入栈，直到找到最左边的节点。然后，我们弹出这个节点并访问它。如果它没有右子树，或者我们已经访问过它的右子树，我们就继续弹出下一个节点。否则，我们将它的右子树入栈，并继续这个过程。

3. 后序遍历

递归版本：

void PostOrder(BiTree T){
    if(T!=NULL){
        PostOrder(T->lchild);
        PostOrder(T->rchild);
        visit(T);
    }
}

栈版本（注意：后序遍历的栈实现稍微复杂一些，因为需要记录节点是否被访问过）：

void PostOrderWithStack(BiTree T){
    if(T==NULL) return;
    Stack S1, S2;
    InitStack(S1);
    InitStack(S2);
    Push(S1, T);
    BiTree prev = NULL;
    while(!IsEmpty(S1)){
        BiTree T = Pop(S1);
        Push(S2, T);
        if(T->lchild!=NULL){
            Push(S1, T->lchild);
        }
        if(T->rchild!=NULL){
            Push(S1, T->rchild);
        }
    }
    while(!IsEmpty(S2)){
        T = Pop(S2);
        if(prev==NULL || prev->lchild!=T && prev->rchild!=T){
            visit(T);
        }
        prev = T;
    }
}