二叉树建立、遍历（递归非递归），求结点等

/*(1）输入完全二叉树的先序序列，用#代表虚结点（空指针），如ABD###CE##F##，建立二叉树的二叉链表。 
（2）写出对用二叉链表存储的二叉树进行先序、中序和后序遍历的递归和非递归算法。
（3）写出对用二叉链表存储的二叉树进行层次遍历算法。
（4）求二叉树的所有叶子及结点总数。
*/
#include"stdio.h"
#include"stdlib.h"
#define STACK_INIT_SIZE 100
#define STACKINCREMENT 10


typedef struct BiTNode{//二叉树的二叉链表
    char data;
    struct BiTNode *lchild,*rchild;
}BiTNode,*BiTree;

typedef struct{        //栈
    BiTree *base;
    BiTree *top;
    int stacksize;
}SqStack;

void InitStack(SqStack &S){//建立空栈
    S.base=(BiTree*)malloc(STACK_INIT_SIZE*sizeof(BiTree));
    if(!S.base)
        exit(0);
    S.top=S.base;
    S.stacksize=STACK_INIT_SIZE;
}

int GetTop(SqStack S,BiTree &e){//取栈顶元素
    if(S.top==S.base)
        return 0;
    e=*(S.top-1);
    return 1;
}

void Push(SqStack &S,BiTree e){//入栈
    if(S.top-S.base>=S.stacksize){//栈满
        S.base=(BiTree*)realloc(S.base,(S.stacksize+STACKINCREMENT)*sizeof(BiTree));
        if(!S.base)
            exit(0);
        S.top=S.base+S.stacksize;
        S.stacksize+=STACKINCREMENT;
    }
    *S.top++=e;
}

void Pop(SqStack &S,BiTree &e){//出栈
    if(S.top==S.base)
        exit(0);
    e=*--S.top;

}

int StackEmpty(SqStack S){//判空
    if(S.top==S.base)
        return 1;
    return 0;
}

typedef struct QNode{//队列
    BiTree tree;
    struct QNode *next;
}QNode,*QueuePtr;

typedef struct LinkQueue{
    QueuePtr fornt;
    QueuePtr rear;
}LinkQueue;

void InitQueue(LinkQueue &Q){//建立新的队列
    Q.fornt=Q.rear=(QueuePtr)malloc(sizeof(QNode));
    Q.fornt->next=NULL;
}

void EnQueue(LinkQueue &Q,BiTree t){//入队列
    QueuePtr p;
    p=(QueuePtr)malloc(sizeof(QNode));
    p->tree=t;
    p->next=NULL;
    Q.rear->next=p;
    Q.rear=p;
}

int EmptyQueue(LinkQueue Q){//判空
    if(Q.fornt==Q.rear)
        return 1;
    return 0;
}

void DeQueue(LinkQueue &Q,BiTree &t){//出队列
    QueuePtr p;
    if(Q.fornt==Q.rear)
        exit(0);
    p=Q.fornt->next;
    t=p->tree;
    Q.fornt->next=p->next;
    if(Q.rear==p)
        Q.rear=Q.fornt;
    free(p);
}

void CreateBiTree(BiTree &T){//建立二叉树（二叉链表）
    char ch;
    scanf("%c",&ch);
    if(ch=='#')
        T=NULL;
    else{
        T=(BiTNode*)malloc(sizeof(BiTree));
        if(!T)
            exit(0);
        T->data=ch;
        CreateBiTree(T->lchild);
        CreateBiTree(T->rchild);
    }
}


void PreOrderTraverse(BiTree T){//递归先序遍历
    if(T){
        printf("%c",T->data);
        PreOrderTraverse(T->lchild);
        PreOrderTraverse(T->rchild);
    }
}

void PreOrderTraverseStack(BiTree T){
    SqStack S;
    BiTree p;

    InitStack(S);
    p=T;
    while (p || !StackEmpty(S)) {   //栈不空或者p不空时循环
        if (p != NULL) {
            Push(S,p);         //存入栈中
            printf("%c",p->data);  //访问根节点
            p = p->lchild;          //遍历左子树
        } 
        else {
            Pop(S,p);
            p = p->rchild;          //访问右子树
        }
    }

}

void InOrderTraverse(BiTree T){//递归中序遍历
    if(T){
        InOrderTraverse(T->lchild);
        printf("%c",T->data);
        InOrderTraverse(T->rchild);
    }
}

void InOrderTraverseStack(BiTree T){//非递归中序遍历
    SqStack S;
    BiTree p;

    InitStack(S);
    p=T;
    while(p || !StackEmpty(S)){
        if(p){
            Push(S,p);
            p=p->lchild;
        }
        else{
            Pop(S,p);
            printf("%c",p->data);
            p=p->rchild;
        }
    }
    printf("\n");
}

void PostOrderTraverse(BiTree T){//递归后序遍历
    if(T){
        PostOrderTraverse(T->lchild);
        PostOrderTraverse(T->rchild);
        printf("%c",T->data);
    }
}

void PostOrderTraverseStack(BiTree T){
    SqStack S;
    BiTree p;
    BiTree q;

    if(T){
        InitStack(S);
        Push(S,T);
        while(!StackEmpty(S)){
            while(GetTop(S,p) && p)
                Push(S,p->lchild);
            Pop(S,p);
            if(!StackEmpty(S)){
                GetTop(S,p);
                if(p->rchild)
                    Push(S,p->rchild);
                else{
                    Pop(S,p);
                    printf("%c",p->data);
                    while(!StackEmpty(S) && GetTop(S,q) && q->rchild==p){
                        Pop(S,p);
                        printf("%c",p->data);
                    }
                    if(!StackEmpty(S)){
                        GetTop(S,p);
                        Push(S,p->rchild);
                    }
                }
            }
        }
    }

}

void LevelTraverse(BiTree T){//层次遍历
    LinkQueue q;
    BiTree p;
    InitQueue(q);      
    p=T;

    EnQueue(q,p);     
    while(!EmptyQueue(q)){
        DeQueue(q,p);  
        printf("%c",p->data);
        if(p->lchild!=NULL)
            EnQueue(q,p->lchild);             
        if(p->rchild!=NULL)
            EnQueue(q,p->rchild);            
    }
    printf("\n");
 }

void BiTreeLeaves(BiTree T){//求叶子结点
    BiTree p=T;
    if(T!=NULL){
        if(p->lchild==NULL && p->rchild==NULL)
            printf("叶子结点是%c\n",p->data);
        if(p->lchild!=NULL)
            BiTreeLeaves(p->lchild);
        if(p->rchild!=NULL)
            BiTreeLeaves(p->rchild);
    }
}

void NodeNumber(BiTree T){//层次遍历
    LinkQueue q;
    BiTree p;
    int i=0;
    InitQueue(q);      //初始化一个空的队列
    p=T;

    EnQueue(q,p);      //入队
    while(!EmptyQueue(q)){
        DeQueue(q,p);  
        i++;
        if(p->lchild!=NULL)
            EnQueue(q,p->lchild);             //访问左子树
        if(p->rchild!=NULL)
            EnQueue(q,p->rchild);             //访问右子树
    }
    printf("结点总数为%d\n",i);
 }


int main(){
    BiTree T;

    CreateBiTree(T);

    PreOrderTraverse(T);
    printf("\n");
    PreOrderTraverseStack(T);
    printf("\n");
    InOrderTraverse(T);
    printf("\n");
    InOrderTraverseStack(T);
    printf("\n");
    printf("\n");
    PostOrderTraverseStack(T);
    printf("\n");

    BiTreeLeaves(T);    
    printf("\n");
    LevelTraverse(T);
    NodeNumber(T);
    return 0;
}