二叉树的非递归遍历(定长顺序栈)

二叉树的抽象数据类型

typedef struct Node
{/*二叉树*/
    char data;
    struct Node* Lchild;
    struct Node* Rchild;
}BTNode;

先序遍历

void PreOrder(BTNode* A)
{/*先序非递归遍历*/
    SeqStack* B = InitStack();
    while (A != NULL || !IsEmptyStack(B))
    {/*当前结点指针及栈均空，则结束*/
        if(A != NULL)
        {/*访问根节点，根指针进栈，进入左子树*/
            printf("%c", A->data);
            PushStack(B, A);
            A = A->Lchild;
        }
        else
        {/*根指针退栈，进入其右子树*/
            PopStack(B, &A);
            A = A->Rchild;
        }
    }
}

中序遍历

void InOrder(BTNode* A)
{/*中序非递归遍历*/
    SeqStack* B = InitStack();
    while (A != NULL || !IsEmptyStack(B))
    {
        if (A != NULL)
        {
            PushStack(B, A);
            A = A->Lchild;
        }
        else
        {
            PopStack(B, &A);
            printf("%c", A->data);
            A = A->Rchild;
        }
    }
}

后序遍历

void PostOrder(BTNode* A)
{
    SeqStack* B = InitStack();
    BTNode* P = NULL;
    while (A != NULL || !IsEmptyStack(B))
    {
        if (A != NULL)
        {
            PushStack(B, A);
            A = A->Lchild;
        }
        else
        {
            TopStack(B, &A);
            if (A->Rchild == NULL || A->Rchild == P)
            {/*判断栈顶结点的右子树是否为空，右子树是否刚访问过*/
                PopStack(B, &A);
                printf("%c", A->data);
                P = A;
                A = NULL;
            }
            else
            {
                A = A->Rchild;
            }
        }
    }
}

源代码

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
#define MAXSIZE 100

typedef struct Node
{/*二叉树*/
    char data;
    struct Node* Lchild;
    struct Node* Rchild;
}BTNode;

typedef struct
{/*定长顺序栈*/
    BTNode* elem[MAXSIZE];
    int top;
}SeqStack;

SeqStack* InitStack();
int IsEmptyStack(SeqStack* A);
int PushStack(SeqStack* A, BTNode* B);
int PopStack(SeqStack* A, BTNode** B);
int TopStack(SeqStack* A, BTNode** B);

BTNode* CreateBinaryTree();
void PreOrder(BTNode* A);
void InOrder(BTNode* A);
void PostOrder(BTNode* A);

int main(void)
{
    BTNode* A;

    printf("请输入该二叉树先序遍历序列(用^表示空子树,叶子结点要跟两个^)：\n");
    A = CreateBinaryTree();

    printf("先序非递归遍历：");
    PreOrder(A);

    printf("\n中序非递归遍历：");
    InOrder(A);

    printf("\n后序非递归遍历：");
    PostOrder(A);

    system("pause");
    return 0;
}

SeqStack* InitStack()
{
    SeqStack* A;
    A = (SeqStack*)calloc(1, sizeof(SeqStack));
    A->top = -1;
    return A;
}

int IsEmptyStack(SeqStack* A)
{
    if (A->top == -1)
    {/*空栈*/
        return 1;
    }
    else
    {
        return 0;
    }
}

int PushStack(SeqStack* A, BTNode* B)
{
    if (A->top == MAXSIZE - 1)
    {
        return 1;
    }
    else
    {
        A->top++;
        A->elem[A->top] = B;
        /*printf("\n结点%c进栈了\n", A->elem[A->top]->data);*/
        return 0;
    }
}


int PopStack(SeqStack* A , BTNode** B)
{
    if (IsEmptyStack(A))
    {
        return 1;
    }
    else
    {
        (* B) = A->elem[A->top];
        /*printf("\n结点%c出栈了\n", (*B)->data);*/
        A->top--;
        return 0;
    }
}

int TopStack(SeqStack* A, BTNode** B)
{
    if (IsEmptyStack(A))
    {
        return 1;
    }
    else
    {
        (*B) = A->elem[A->top];
        return 0;
    }
}

BTNode* CreateBinaryTree()
{
    BTNode* A = NULL;
    char ch = '\0';

    ch = getchar();
    if (ch == '^')
    {
        return NULL;
    }
    else
    {
        A = (BTNode*)calloc(1, sizeof(BTNode));
        A->data = ch;
        A->Lchild = CreateBinaryTree(A->Lchild);
        A->Rchild = CreateBinaryTree(A->Rchild);
        return A;
    }
}

void PreOrder(BTNode* A)
{/*先序非递归遍历*/
    SeqStack* B = InitStack();
    while (A != NULL || !IsEmptyStack(B))
    {/*当前结点指针及栈均空，则结束*/
        if(A != NULL)
        {/*访问根节点，根指针进栈，进入左子树*/
            printf("%c", A->data);
            PushStack(B, A);
            A = A->Lchild;
        }
        else
        {/*根指针退栈，进入其右子树*/
            PopStack(B, &A);
            A = A->Rchild;
        }
    }
}

void InOrder(BTNode* A)
{/*中序非递归遍历*/
    SeqStack* B = InitStack();
    while (A != NULL || !IsEmptyStack(B))
    {
        if (A != NULL)
        {
            PushStack(B, A);
            A = A->Lchild;
        }
        else
        {
            PopStack(B, &A);
            printf("%c", A->data);
            A = A->Rchild;
        }
    }
}

void PostOrder(BTNode* A)
{
    SeqStack* B = InitStack();
    BTNode* P = NULL;
    while (A != NULL || !IsEmptyStack(B))
    {
        if (A != NULL)
        {
            PushStack(B, A);
            A = A->Lchild;
        }
        else
        {
            TopStack(B, &A);
            if (A->Rchild == NULL || A->Rchild == P)
            {/*判断栈顶结点的右子树是否为空，右子树是否刚访问过*/
                PopStack(B, &A);
                printf("%c", A->data);
                P = A;
                A = NULL;
            }
            else
            {
                A = A->Rchild;
            }
        }
    }
}