二叉树的建立和遍历

#include<iostream>
#include <stack>

using namespace std;

//本文用前序遍历、中序遍历、后序遍历实现二叉树的建立，再用三种遍历方法实现遍历输出

//构建节点的数据结构
typedef struct BiNode
{
    char data;
    struct BiNode *lchild,*rchild;
}BiNode,*BiTree;

/*
//构建节点的数据结构
typedef struct BiNode
{
    char data;
    struct BiNode lchild,rchild; //这里写成这样子是不对的，因为还没有定义完成BiNode结构体，并不知道给lchild分配多少空间，所以会报错，
                                    但是如果像上面一样定义指针的话，不需要分配空间，所以不会报错
}BiNode,*BiTree;
*/

//前序遍历方式创建二叉树
//void createPreBst(BiTree T) 这里这样子写会出现错误，因为值传递和地址传递和引用传递的区别。

void createPreBst(BiTree &T) //指针的值改变，之后就会被释放，应该改变指针的地址。 这里可以是引用也可以是指针
{
    char inPut;
    scanf("%c",&inPut);
    if(inPut == '#')
    {
        T = NULL;
    }
    else
    {
        T = (BiTree)malloc(sizeof(BiNode));
        if(T == NULL)
        exit(OVERFLOW);

        T->data = inPut;
        createPreBst(T->lchild);
        createPreBst(T->rchild);
    }
}

/* 这里面是不对的，不能仅仅用简单的交换来达到中序和后序的实现！！
//中序遍历方式创建二叉树
void createInBst(BiTree &T)
{
    char inPut;
    scanf("%c",&inPut);
    if(inPut == '#')
    {
        T = NULL;
    }
    else
    {
        T = (BiTree)malloc(sizeof(BiNode));
        if(T == NULL)
            exit(OVERFLOW);

        

        createInBst(T->lchild);
        T->data = inPut;
        createInBst(T->rchild);
    }
}



void createPostBst(BiTree &T)
{
    char inPut;
    scanf("%c",&inPut);
     if(inPut == '#')
    {
        T = NULL;
    }
    
    if(T==NULL)
          T = (BiTree)malloc(sizeof(BiNode));
        //if(T == NULL)
        //    exit(OVERFLOW);

        
        createPostBst(T->lchild);
        createPostBst(T->rchild);
        T->data = inPut;
    
}
*/


//前序遍历方式输出（递归法）

void preOrder(BiTree T)
{
    if(T == NULL)
    {
        return;
    }
    printf("%c ", T->data);
    preOrder(T->lchild);
    preOrder(T->rchild);
}

//前序遍历方式输出（非递归法） 用一个栈来实现
void preOrder01(BiTree T)
{
    stack <BiTree> sta;
    if( T == NULL)
    {
        return;
    }
    //while(T || sta.empty() != 0) 这里的empty的值不能是零，empty() 堆栈为空则返回真
    while(T || sta.empty() != true)
    {
        while(T)
        {
            sta.push(T);
            printf("%c",T->data);
            T = T->lchild;
        }

        T = sta.top();
        sta.pop();
        T = T->rchild;
    }

}

//中序遍历方式输出（递归法）
void inOrder(BiTree T)
{
    if(T == NULL)
    {
        return;
    }
    
    inOrder(T->lchild);
    printf("%c ", T->data);
    inOrder(T->rchild);
}

//中序遍历方式输出（非递归法）  
void inOrder02(BiTree T)
{
    if(T == NULL)
    {
        return;
    }
    stack<BiTree > sta;

    //while(T || sta.empty() != 0) 这里的empty的值不能是零，empty() 堆栈为空则返回真
    while(T || sta.empty() != true)
    {
        while(T)
        {
            sta.push(T);
            T = T->lchild;
        }

        T = sta.top();
        printf("%c" , T->data);
        sta.pop();
        T = T->rchild ;
    }

}

//后序遍历方式输出（递归法）
void postOrder(BiTree &T)
{
    if(T == NULL)
    {
        return;
    }
    
    postOrder(T->lchild);
    postOrder(T->rchild);
    printf("%c ", T->data);
}

//后序遍历方式输出（非递归法）  用两个栈实现
void postOrder02(BiTree T)
{
    stack <BiTree> sta;
    stack <BiTree> sta2;
    if( T == NULL)
    {
        return;
    }

    sta.push(T);
    while(sta.empty() != true)
    {
        T = sta.top();
        sta.pop();
        sta2.push(T);
        if(T->lchild != NULL)
        {
            sta.push(T->lchild);
        }
        if(T->rchild != NULL)
        {
            sta.push(T->rchild);
        }
    }

    while(sta2.empty() != true)
    {
        BiTree temp = sta2.top();
        cout<< temp->data <<' ';
        sta2.pop();
    }


}
//后序遍历方式输出（非递归法）  用1个栈实现
//这里回退的时候，必须知道知否遍历过了，要有标识
void postOrder03(BiTree T)
{
    stack <BiTree> sta;
    
    if( T == NULL)
    {
        return;
    }

    sta.push(T);
    BiTree temp = T;
    while(sta.empty() != true)
    {
        T = sta.top();
        if(T->lchild != NULL  && temp != T->lchild && temp != T->rchild)
　　　　　　　　　　　　　　//if(T->lchild != NULL  && temp != T->lchild ) 上面的如果不加另一个约束项会陷入无限的循环
        {
            sta.push(T->lchild);
        }
        else if (T->rchild != NULL  && temp != T->rchild)
        {
            sta.push(T->rchild);
        }
        else
        {
            sta.pop();
            temp = T;
            cout<< T->data << ' ';
        }
    }

}

int main()
{
    BiTree Tr;//
    //Tree->lchild = Tree->rchild = NULL; 加上这样子的句子 也不对
    //BiTree Tr = {''};
    //Tr=(BiTree)malloc(sizeof(BiNode));
    createPreBst(Tr);
    postOrder02(Tr); //这种也会引发值传递和地址传递的情况，但是由于打印语句是在函数中，所以结果是对的，但是有隐患。
    system("pause");
}

 这里面有很多的盲点，比如stl中栈的empty（）返回的是真。

在结构体中不能声明结构体类型的变量，但可以声明结构体类型的指针（这个与分不分配内存有关系）