数据结构设计——二叉树实现

   本篇文章中所有数据结构都是后期整理的，如有问题欢迎指正，转载请注明出处http://www.cnblogs.com/a1982467767/p/8893567.html

 

二叉树操作设计和实现

实验目的：

掌握二叉树的定义、性质及存储方式，各种遍历算法。

 

实验要求：

采用二叉树链表作为存储结构，完成二叉树的建立，先序、中序和后序以及按层次遍历的操作，求所有叶子及结点总数的操作。

#include <stdio.h>
#include <stdlib.h>
typedef char DataType;
typedef struct node{
    DataType data;
    struct node *lchild,*rchild;
}Bnode, *BTree;
int count;
void CreateBTree(BTree *T);
void PreorderN(BTree T);
void MiddleN(BTree T);
void LatterN(BTree T);

#define StackSize 100 /*假定预分配的栈空间最多为10*/
typedef BTree SDataType; /*栈的元素类型设为整型*/
#define Error printf

typedef struct{
    SDataType data[StackSize];
    int top;
}SeqStack;

SeqStack * InitStack(void) /*初始栈*/
{
    SeqStack *S = (SeqStack *)malloc(sizeof(SeqStack) * StackSize); 
    S->top=-1;
}

int StackEmpty(SeqStack *S) /*判栈空*/
{
    return S->top==-1;
}

int StackFull(SeqStack *S) /*判栈满*/
{
    return S->top==StackSize-1;
}

void Push(SeqStack *S, SDataType x) /*进栈*/
{
    if(StackFull(S))
        Error("STACK FULL!
"); /*上溢退出*/
    else
        S->data[++S->top]=x; /*栈顶指针加1后将x进栈*/
}

SDataType Pop(SeqStack *S) /*出栈*/
{
    if (StackEmpty(S))
        Error("Stack underflow"); /*下溢退出*/
    else
        return S->data[S->top--]; /*栈顶指针返回后将栈顶指针减1*/
}

SDataType StackTop(SeqStack *S) /*取栈顶元素*/
{
    if (StackEmpty(S))
        Error("STACK EMPTY!
");
    return S->data[S->top];
}

main()
{
    BTree T;
    char ch1,ch2;
    printf("
PLEASE SELECT:
");
    ch1='y';
    while(ch1=='y' || ch1=='Y')
    {
        printf("
A------------------------CREATE BITREE");
        printf("
B-------------------------DLR(NO DI IGU)");
        printf("
C----------------------Middle(NO DI IGU)");
        printf("
D----------------------Latter(NO DI IGU)");
        printf("
E-------------------------EXIT
");
        scanf("
%c",&ch2);
        switch(ch2)
        {
        case 'A':
        case 'a':printf("INPUT NODE:
");
        CreateBTree(&T);
        printf("CREATE SUCC
");break;
        case 'B':
        case 'b':printf("BIAN LI JIE GUO
");
                    PreorderN(T);break;
        case 'C':
        case 'c':printf("Middle Bian Li Jie Guo
");
            MiddleN(T);break;
        case 'D':
        case 'd':printf("Latter Bian Li Jie Guo
");
            LatterN(T);break;
        case 'E':
        case 'e':ch1='n';break;
        default:ch1='n';
        }
    }
}
void CreateBTree(BTree *T)
{
    char ch;
    scanf("
%c",&ch);
    if (ch=='0')
        *T=NULL;
    else 
    {
        *T=(Bnode*)malloc(sizeof(Bnode));
        (*T)->data=ch;
        CreateBTree(&(*T)->lchild);
        CreateBTree(&(*T)->rchild);
    }
}
void PreorderN(BTree T)
{/*先序遍历二叉树T的非递归算法*/
    SeqStack *S;
    BTree p;
    p = T;
    S = InitStack(); 
    while(!StackEmpty(S) || p != NULL)
    {
        if(p)
        {    
            printf("%3c",p->data); /*访问入栈结点的数据域*/
            Push(S,p); /*向左走到尽头*/
            p = p->lchild;
        }
        else
        {
            p =    Pop(S);
            p = p->rchild;
        }
    }
}/*PreorderN */

void MiddleN(BTree T)
{
    SeqStack *S;
    BTree p;
    p = T;
    S = InitStack(); 
    while(!StackEmpty(S) || p != NULL)
    {
        if(p)
        {    
             /*向左走到尽头*/
            Push(S,p);
            p = p->lchild;
        }    
        else
        {
            p =    Pop(S);
            printf("%3c",p->data);/*访问入栈结点的数据域*/
            p = p->rchild;
        }
    }
}

void LatterN(BTree T)
{
    SeqStack *S1,*S2;
    BTree p;
    p = T;
    S1 = InitStack(); 
    S2 = InitStack(); 
    while(!StackEmpty(S1) || p != NULL)
    {
        if(p)
        {    
             /*向左走到尽头*/
            Push(S1,p);
            Push(S2,p);
            p = p->rchild;
        }    
        else
        {
            p =    Pop(S1);
            p = p->lchild;
        }        
    }
    while(!StackEmpty(S2))
    {
        p = Pop(S2);
        printf("%3c",p->data);/*访问入栈结点的数据域*/
    }
}