用栈实现二叉树的非递归中序遍历

另见求树高 http://blog.csdn.net/Justme0/article/details/7694704

/********************************************************************
created:    2014/05/11 23:13
filename:    main.c
author:        Justme0 (http://blog.csdn.net/justme0)

purpose:    用栈实现二叉树的非递归中序遍历
*********************************************************************/

#define _CRT_SECURE_NO_WARNINGS

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

typedef struct Node Node;
typedef struct Stack Stack;
typedef char TElemType;
typedef Node * SElemType;

#pragma region 栈的定义

#define STACK_INIT_SIZE 100
#define STACKINCREMENT 10

struct Stack {
    SElemType *base;
    SElemType *top;
    int stacksize;
};

void InitStack(Stack *pS)
{
    (*pS).base=(SElemType*)malloc(STACK_INIT_SIZE*(sizeof(SElemType)));
    if(!(*pS).base)
        exit(-2);
    (*pS).top=(*pS).base;
    (*pS).stacksize=STACK_INIT_SIZE;
}

void Push(Stack *pS,SElemType T)
{
    if((*pS).top-(*pS).base>=(*pS).stacksize)
    {
        (*pS).base=(SElemType*)realloc((*pS).base,((*pS).stacksize+STACKINCREMENT)*sizeof(SElemType));
        if(!(*pS).base)
            exit(-2);
        (*pS).top=(*pS).base+(*pS).stacksize;
        (*pS).stacksize+=STACKINCREMENT;
    }
    *(*pS).top++=T;
}

int StackEmpty(Stack S)
{
    return S.top == S.base;
}

int Pop(Stack (*pS),SElemType *pT)
{
    if(StackEmpty(*pS))
        return 0;
    *pT=*(--(*pS).top);
    return 1;
}

int GetTop(Stack S,SElemType *pT)
{
    if(StackEmpty(S))
        return 0;
    (*pT)=*(S.top-1);
    return 1;
}

#pragma endregion 栈的定义

int Print(TElemType a)
{
    printf("%c
", a);

    return 1;
}

#pragma region 二叉树

struct Node {
    TElemType data;
    Node *lchild;
    Node *rchild;
};

int CreatBiTree(Node **pT)
{//先序法创建二叉树，空格字符表示空树,每个节点一个字符
    //构造二叉链表表示的二叉树
    TElemType ch;
    scanf("%c",&ch);
    getchar();
    if(ch==' ')
    {
        *pT = NULL;
    }
    else
    {
        if(!(*pT=(SElemType)malloc(sizeof(Node))))
            exit(-2);
        (*pT)->data=ch;             //生成根节点
        CreatBiTree(&((*pT)->lchild));     //构造左子树
        CreatBiTree(&((*pT)->rchild));    //构造右子树
    }

    return 1;
}

//中序遍历二叉树T的非递归算法，对每个数据元素调用函数Visit。
int InOrderTraverse(Node *T, int (*Visit)(TElemType e))
{
    Stack S;
    Node *p = NULL;
    S.base=(Node **)malloc(100*(sizeof(Node **)));
    InitStack(&S);
    Push(&S,T);
    while(!StackEmpty(S))
    {
        while(GetTop(S,&p)&&p)
            Push(&S,p->lchild);
        Pop(&S,&p);
        if(!StackEmpty(S))
        {
            Pop(&S,&p);
            assert(NULL != p);
            if(!Visit(p->data))
                return -1;
            Push(&S,(p->rchild));
        }
    }
    return 1;
}

#pragma endregion 二叉树

int main(void)
{
    Node *T  = NULL;
    freopen("cin.txt", "r", stdin);

    CreatBiTree(&T);
    InOrderTraverse(T, Print);

    // TODO: FreeTree(T);

    system("PAUSE");
    return 0;
}

/* cin.txt
A
B
C


D
E

G


F



*/