使用栈实现中序遍历树

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

int MAXSIZE = 100;
const int BLOCK_SIZE = 20;

//顺序表示
//#define MAXSIZE 100
//typedef TElemType SqBiTree[MAXSIZE]
//
//SqBiTree bt;

typedef struct BiNode
{
    int data;
    BiNode* lchild, * rchild;
}BiNode,*BiTree;

typedef struct {
    BiTree* base;
    BiTree* top;
    int stacksize;
} SqStack;//栈里放的是指针而不是值 所以base和top应该是个指向指针的指针

bool InitSqStack(SqStack& S)
{
    S.base = new BiTree[MAXSIZE];//new存放指针的数组空间 首地址给base
    if (!S.base)
        return false;
    S.top = S.base;
    S.stacksize = MAXSIZE;
    return true;
}

bool IsEmpty(SqStack S)
{
    if (S.top == S.base)
        return true;
    else
        return false;
}

bool Push(SqStack& S, BiTree e)
{
    if (S.top - S.base == S.stacksize)
    {
        BiTree* p = new BiTree[MAXSIZE + BLOCK_SIZE];
        for (int i = 0; i < S.stacksize; i++)
        {
            p[i] = S.base[i];
        }
        delete[] S.base;
        S.base = p;
        S.top = &p[S.stacksize];
        MAXSIZE += BLOCK_SIZE;
    }
    *S.top++ = e;
    return true;
}

BiTree& Pop(SqStack& S, BiTree& e)
{
    if (IsEmpty(S))
    {
        exit(1);
    }
    e = *--S.top;
    return e;
}

//仅为简单的create 后续需要完善
BiNode* createNode(int data) 
{
    BiNode* newNode = (BiNode*)malloc(sizeof(BiNode));
    newNode->data = data;
    newNode->lchild = newNode->rchild = NULL;
    return newNode;
}

void visit(BiTree& T)
{
    printf("%d\t", T->data);
}

bool PreOrderTraverse(BiTree& T)
{
    if (T == nullptr)
    {
        return true;
    }
    //访问根结点
    visit(T);
    //递归遍历左孩子
    PreOrderTraverse(T->lchild);
    //递归遍历右孩子
    PreOrderTraverse(T->rchild);
    return true;
}

bool InOrderTraverse(BiTree& T)
{
    if (T == nullptr)
    {
        return true;
    }
    //第一步：访问左孩子
    InOrderTraverse(T->lchild);
    //第二步：访问根结点
    visit(T);
    //第三步：访问右孩子
    InOrderTraverse(T->rchild);
    return true;
}

bool PostOrderTraverse(BiTree& T)
{
    if (T == nullptr)
    {
        return true;
    }
    //第一步：访问左孩子
    PostOrderTraverse(T->lchild);
    //第二步：访问右孩子
    PostOrderTraverse(T->rchild);
    //第三步：访问根结点
    visit(T);
    return true;
}

void LDR_Stack(BiTree& T)//使用栈完成中序遍历
{
    //创建一个栈，用于保存二叉树的结点
    SqStack S;
    InitSqStack(S);
    BiTree p = T;//让指针p指向根结点

    //BiTree q = nullptr;//需要一个指针记录p为空时的上一个结点 用于出栈

    //(直接用栈顶指针也行）
    BiTree t = *S.top;

    while (p || !IsEmpty(S))//如果p不为空(即有结点)且 栈里还有未访问的结点
    {
        if (p)//如果有结点
        {
            Push(S, p);//根结点入栈
            //q = p;
            
            p = p->lchild;//去访问它的左子树
        }
        else//如果没有结点 回去访问根
        {
            //Pop(S, q);//出栈
            //visit(q);
            //p = q->rchild;

            Pop(S, t);//出栈
            visit(t);
            p = t->rchild;
        }
    }
}

int main()
{
    BiNode* root = createNode(1);
    root->lchild = createNode(2);
    root->rchild = createNode(3);
    root->lchild->lchild = createNode(4);
    root->lchild->rchild = createNode(5);

    printf("PreOrder Traversal:\t");
    PreOrderTraverse(root);
    printf("\n");

    printf("InOrder Traversal:\t");
    InOrderTraverse(root);
    printf("\n");

    printf("LDR_Stack Traversal:\t");
    LDR_Stack(root);
    printf("\n");

    printf("PostOrder Traversal:\t");
    PostOrderTraverse(root);
    printf("\n");

    return 0;
}