二叉树的遍历的非递归算法的实现

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

#define INIT_STACK_SIZE 100
#define ADD_SIZE 10

typedef char DataType;

typedef struct Node {
    DataType data;/*数据域*/
    struct Node *lchild;/*左子树指针*/
    struct Node *rchild;/*右子树指针*/
} BiTNode, *BiTree; /*结点的结构体定义*/

typedef BiTNode ElemType;
typedef struct {
    BiTree *top;
    BiTree *base;
    int stacksize;
} TStack;

void InitStack(TStack *TS) {
    TS->base = (BiTree *)malloc(INIT_STACK_SIZE * sizeof(BiTree));

    if(!TS->base) {
        printf("Apply for memory error,new node cannot be created!\n");
        exit(EXIT_FAILURE);
    }
    TS->top = TS->base;
    TS->stacksize = INIT_STACK_SIZE;
}
void Push(TStack *TS, BiTNode *e) {
    if(TS->top - TS->base >= TS->stacksize) {
        //如果栈空间已满，重新分配空间
        TS->base = (BiTree *)realloc(TS->base, (TS->stacksize + ADD_SIZE) * sizeof(BiTree));
        if(!TS->base) {
            printf("Apply for memory failed!\n");
            exit(EXIT_FAILURE);
        }

        TS->top = TS->base + TS->stacksize;
        TS->stacksize += ADD_SIZE;
    }

    *TS->top++ = e;
}
void Pop(TStack *TS, BiTNode **e) {
    if(TS->base != TS->top)
        *e = *--TS->top;
}
int GetTop(TStack TS, BiTNode *e) {
    if(TS.base == TS.top)
        return -1;

    e = *(TS.top - 1);
    return 1;
}
int StackEmpty(TStack TS) {
    return TS.base == TS.top;
}

/*初始化创建二叉树的头结点*/
void Initiate(BiTNode **root) {
    *root = (BiTNode *)malloc(sizeof(BiTNode));
    (*root)->lchild = NULL;
    (*root)->rchild = NULL;
}

void Destroy(BiTNode **root) {
    if((*root) != NULL && (*root)->lchild != NULL)
        Destroy(&(*root)->lchild);

    if((*root) != NULL && (*root)->rchild != NULL)
        Destroy(&(*root)->rchild);

    free(*root);
}

/*若当前结点curr非空，在curr的左子树插入元素值为x的新结点*/
/*原curr所指结点的左子树成为新插入结点的左子树*/
/*若插入成功返回新插入结点的指针，否则返回空指针*/
BiTNode *InsertLeftNode(BiTNode *curr, DataType x) {
    BiTNode *s, *t;
    if(curr == NULL)
        return NULL;

    t = curr->lchild;/*保存原curr所指结点的左子树指针*/
    s = (BiTNode *)malloc(sizeof(BiTNode));
    s->data = x;
    s->lchild = t;/*新插入结点的左子树为原curr的左子树*/
    s->rchild = NULL;

    curr->lchild = s;/*新结点成为curr的左子树*/
    return curr->lchild;/*返回新插入结点的指针*/
}

/*若当前结点curr非空，在curr的右子树插入元素值为x的新结点*/
/*原curr所指结点的右子树成为新插入结点的右子树*/
/*若插入成功返回新插入结点的指针，否则返回空指针*/
BiTNode *InsertRightNode(BiTNode *curr, DataType x) {
    BiTNode *s, *t;

    if(curr == NULL)
        return NULL;

    t = curr->rchild;/*保存原curr所指结点的右子树指针*/
    s = (BiTNode *)malloc(sizeof(BiTNode));
    s->data = x;
    s->rchild = t;/*新插入结点的右子树为原curr的右子树*/
    s->lchild = NULL;

    curr->rchild = s;/*新结点成为curr的右子树*/
    return curr->rchild;/*返回新插入结点的指针*/
}



void PreOrder(BiTNode *t, int visit(DataType item))
//使用visit(item)函数前序遍历二叉树t
{
    if(t != NULL) {
        //此小段有一处错误
        visit(t->data);
        PreOrder(t-> lchild, visit);
        PreOrder(t-> rchild, visit);
    }
}

void InOrder(BiTNode *t, int visit(DataType item))
//使用visit(item)函数中序遍历二叉树t
{
    if(t != NULL) {
        //此小段有一处错误
        InOrder(t->lchild, visit);
        visit(t->data);
        InOrder(t->rchild, visit);
    }
}

void PostOrder(BiTNode *t, int visit(DataType item))
//使用visit(item)函数后序遍历二叉树t
{
    if(t != NULL) {
        //此小段有一处错误
        PostOrder(t->lchild, visit);
        PostOrder(t->rchild, visit);
        visit(t->data);
    }
}
////////////////////////////////////////////////////////
int MyInOrder(BiTNode *T, int visit(DataType item)) {
    TStack TS;

    BiTNode *temp = T;
    InitStack(&TS);
    while(!StackEmpty(TS) || temp) {
//           //中序遍历
//        if(temp){
//            Push(&TS, temp);
//            temp = temp->lchild;
//        }else{
//            Pop(&TS, &temp);
//            if(!visit(temp->data))
//                return -1;
//            temp = temp->rchild;
//        }
//前序遍历，当所有的节点遍历完的时候，栈中剩下的全为根节点
        if(temp) {
            if(!visit(temp->data)){
                return -1;
            }else{
                Push(&TS, temp);
                temp = temp->lchild;
            }
        }
        else{
            Pop(&TS, &temp);
            temp = temp->rchild;
        }
    }

    return 1;
}

int Visit(DataType item) {
    printf("%c ", item);
    return 1;
}

BiTNode *Search(BiTNode *root, DataType x) { //需找元素x是否在二叉树中
    BiTNode *find = NULL;
    if(root != NULL) {
        if(root->data == x)
            find = root;
        else {
            find = Search(root->lchild, x);
            if(find == NULL)
                find = Search(root->rchild, x);
        }
    }
    return find;
}

int main() {
    BiTNode *root, *p, *pp, *find;
    char x = 'E';

    Initiate(&root);
    p = InsertLeftNode(root, 'A');
    p = InsertLeftNode(p, 'B');
    p = InsertLeftNode(p, 'D');
    p = InsertRightNode(p, 'G');
    p = InsertRightNode(root->lchild, 'C');
    pp = p;
    InsertLeftNode(p, 'E');
    InsertRightNode(pp, 'F');

    printf("前序遍历：");
    PreOrder(root->lchild, Visit);
    printf("\n中序遍历：");
    InOrder(root->lchild, Visit);
    printf("\n后序遍历：");
    PostOrder(root->lchild, Visit);

    printf("\n\n现在开始非递归遍历！\n");
    MyInOrder(root->lchild, Visit);

    find = Search(root, x);
    if(find != NULL)
        printf("\n数据元素%c在二叉树中 \n", x);
    else
        printf("\n数据元素%c不在二叉树中 \n", x);

    Destroy(&root);

    return 0;
}