二叉树的非递归遍历

全部代码

#include <stdio.h>
#include <stdlib.h>
#include <assert.h>

typedef struct node
{
    int nValue;
    struct node *pLeft;
    struct node *pRight;
}BiTree;

typedef struct node2
{
    BiTree *nValue;
    struct node2 *pNext;
}MyStack;

typedef struct node3
{
    int nCount;
    MyStack *pTop;
}Stack;

void s_Init(Stack **ppStack)
{
    assert(ppStack != NULL);

    *ppStack = (Stack *)malloc(sizeof(Stack));
    if(NULL == *ppStack)
    {
        printf("栈空间分配失败！\n");
        exit(-1);
    }
    (*ppStack)->nCount = 0;
    (*ppStack)->pTop = NULL;
}

void s_Push(Stack *pStack, BiTree *nNum)
{
    MyStack *pTemp = NULL;

    assert(pStack != NULL);

    //临时节点开辟空间
    pTemp = (MyStack *)malloc(sizeof(MyStack));
    if(NULL == pTemp)
    {
        printf("临时节点空间分配失败！\n");
        exit(-1);
    }
    pTemp->nValue = nNum;
    pTemp->pNext = NULL;

    //头添加
    //临时节点的下一个是头节点
    pTemp->pNext = pStack->pTop;
    //新节点是新栈顶
    pStack->pTop = pTemp;

    //更新栈内元素
    ++pStack->nCount;
}

BiTree *s_Pop(Stack *pStack)
{
    BiTree *nNum;
    MyStack *pDel = NULL;

    assert(pStack!=NULL && pStack->pTop!=NULL);

    //标记  要删除的节点
    pDel = pStack->pTop;
    nNum = pStack->pTop->nValue;
    //栈顶指针下移
    pStack->pTop = pStack->pTop->pNext;
    //释放空间
    free(pDel);
    pDel = NULL;

    //更新栈内元素
    --pStack->nCount;

    return nNum;
}

//递归创建二叉树
void RecCreateBiTree(BiTree **ppRoot)
{
    int nNum;

    assert(ppRoot!=NULL);

    //输入节点的值
    scanf("%d", &nNum);

    //检测是否是结束标志
    if(0 == nNum)
    {
        return;
    }

    *ppRoot = (BiTree *)malloc(sizeof(BiTree));
    if(NULL == *ppRoot)
    {
        printf("*ppRoot空间分配失败！");
        exit(-1);
    }
    (*ppRoot)->nValue = nNum;
    (*ppRoot)->pLeft = NULL;
    (*ppRoot)->pRight = NULL;

    //处理当前节点的左和右
    RecCreateBiTree(&(*ppRoot)->pLeft);
    RecCreateBiTree(&(*ppRoot)->pRight);
}

//非递归前序遍历
void UnRecPrevOrderTraversal(BiTree *pRoot)
{
    Stack *pStack = NULL;

    assert(pRoot!=NULL);

    //申请辅助栈
    s_Init(&pStack);

    while(1)
    {
        //打印根  处理左
        while(pRoot!=NULL)
        {
            printf("%d ", pRoot->nValue);
            s_Push(pStack, pRoot);
            pRoot = pRoot->pLeft;
        }

        //栈顶节点弹出  处理右子树
        pRoot = s_Pop(pStack);

        //栈空  树遍历结束
        if(NULL == pRoot)
        {
            return;
        }

        //处理右
        pRoot = pRoot->pRight;
    }
}

//非递归中序遍历
void UnRecMidOrderTraversal(BiTree *pRoot)
{
    Stack *pStack = NULL;

    assert(pRoot!=NULL);

    //申请辅助栈
    s_Init(&pStack);

    while(1)
    {
        //处理左
        while(pRoot)
        {
            s_Push(pStack, pRoot);
            pRoot = pRoot->pLeft;
        }

        //栈顶节点弹出
        pRoot = s_Pop(pStack);

        //栈空  树遍历结束
        if(NULL == pRoot)
        {
            return;
        }

        //打印左
        printf("%d ", pRoot->nValue);

        //处理右
        pRoot = pRoot->pRight;
    }
}

//非递归后序遍历
void UnRecLastOrderTraversal(BiTree *pRoot)
{
    Stack *pStack = NULL;
    BiTree *pFlag = NULL;

    assert(pRoot!=NULL);

    //申请辅助栈
    s_Init(&pStack);

    while(1)
    {
        //处理左
        while(pRoot)
        {
            s_Push(pStack, pRoot);
            pRoot = pRoot->pLeft;
        }

        //空栈 结束
        if(NULL == pStack->pTop)
        {
            return;
        }

        //栈顶元素的右为空  或者已经被处理过 弹出  标记
        if(NULL==pStack->pTop->nValue->pRight || pStack->pTop->nValue->pRight==pFlag)
        {
            pFlag = s_Pop(pStack);
            printf("%d ", pFlag->nValue);
        }
        //未被处理过  继续处理右
        else
        {
            pRoot = pStack->pTop->nValue->pRight;
        }
    }
}

int main(void)
{
    BiTree *pRoot = NULL;
    RecCreateBiTree(&pRoot);
    UnRecPrevOrderTraversal(pRoot);
    printf("\n");
    UnRecMidOrderTraversal(pRoot);
    printf("\n");
    UnRecLastOrderTraversal(pRoot);
    printf("\n");

    return 0;
}