数据结构——键树之双链表

#include "stdio.h"
#include "stdlib.h"
#include "string.h"

#define OK 1
#define ERROR 0
typedef int Status; // Status是函数的类型,其值是函数结果状态代码，如OK等
typedef int Boolean; // Boolean是布尔类型,其值是TRUE或false
#define N 16 // 数据元素个数
#define MAXKEYLEN 16 // 关键字的最大长度
#define Nil ' ' //定义结束符为空格
#define STACK_INIT_SIZE 10 // 存储空间初始分配量
#define STACKINCREMENT 2 // 存储空间分配增量

struct Others // 记录的其它部分
 {
   int ord;
 };

struct KeysType // 关键字类型
 {
   char ch[MAXKEYLEN]; // 关键字
   int num; // 关键字长度
 };

 struct Record // 记录类型
 {
   KeysType key; // 关键字
   Others others; // 其它部分(由主程定义)
 };

enum NodeKind{LEAF,BRANCH}; // 结点种类:{叶子,分支}

typedef struct DLTNode // 双链树类型
 {
   char symbol;
   DLTNode *next; // 指向兄弟结点的指针
   NodeKind kind;
   union
   {
     Record *infoptr; // 叶子结点的记录指针
     DLTNode *first; // 分支结点的孩子链指针
   };
 }DLTNode,*DLTree;

 struct SElemType // 定义栈元素类型
 {
   char ch;
   DLTree p;
 };
 struct SqStack
 {
   SElemType *base; // 在栈构造之前和销毁之后，base的值为NULL
   SElemType *top; // 栈顶指针
   int stacksize; // 当前已分配的存储空间，以元素为单位
 }; // 顺序栈

 Status InitDSTable(DLTree &DT)
 { // 操作结果: 构造一个空的双链键树DT
   DT=NULL;
   return OK;
 }//InitDSTable

 void DestroyDSTable(DLTree &DT)
 { // 初始条件: 双链键树DT存在。操作结果: 销毁双链键树DT
   //我们采用深度优先来销毁。
   if(DT) // 非空树
   {
     if(DT->kind==BRANCH&&DT->first) // *DT是分支结点且有孩子
       DestroyDSTable(DT->first); // 销毁孩子子树
     if(DT->next) // 有兄弟
       DestroyDSTable(DT->next); // 销毁兄弟子树
     free(DT); // 释放根结点
     DT=NULL; // 空指针赋0
   }
 }//DestroyDSTable

void print(Record e)
 {
   int i;
   printf("(");
   for(i=0;i<e.key.num;i++)
     printf("%c",e.key.ch[i]);
   printf(",%d)",e.others.ord);
 }//print

Record *SearchDLTree(DLTree T,KeysType K)
 { // 在非空双链键树T中查找关键字等于K的记录，若存在，
   // 则返回指向该记录的指针，否则返回空指针。算法9.15，有改动
   DLTree p;
   int i;
   if(T)
   {
     p=T; // 初始化
     i=0;
     while(p&&i<K.num)
     {
       while(p&&p->symbol!=K.ch[i]) // 查找关键字的第i位
         p=p->next;
       if(p&&i<K.num) // 准备查找下一位
         p=p->first;
       ++i;
     } // 查找结束

     if(!p) // 查找不成功
       return NULL;
     else // 查找成功
       return p->infoptr;
   }//if
   else
     return NULL; // 树空
 }//SearchDLTree

 void InsertDSTable(DLTree &DT,Record *r)
 { // 初始条件: 双链键树DT存在，r为待插入的数据元素的指针
   // 操作结果: 若DT中不存在其关键字等于(*r).key.ch的数据元素，
   //           则按关键字顺序插r到DT中
   DLTree p=NULL,q,ap;
   int i=0;
   KeysType K=r->key;
   if(!DT && K.num) // 空树且关键字符串非空
   {
     DT=ap=(DLTree)malloc(sizeof(DLTNode));
     for(;i<K.num;i++) // 插入分支结点
     {
       if(p)
         p->first=ap;
       ap->next=NULL;
       ap->symbol=K.ch[i];
       ap->kind=BRANCH;
       p=ap;
       ap=(DLTree)malloc(sizeof(DLTNode));
     }//for

     p->first=ap; // 插入叶子结点
     ap->next=NULL;
     ap->symbol=Nil;
     ap->kind=LEAF;
     ap->infoptr=r;//在叶子结点处记录指向该关键字的指针
   }//if
   else // 非空树
   {
     p=DT; // 指向根结点
     while(p&&i<K.num)
     {
       while(p&&p->symbol<K.ch[i]) // 沿兄弟结点查找
       {
         q=p;
         p=p->next;
       }//while
       if(p&&p->symbol==K.ch[i]) // 找到与K.ch[i]相符的结点
       {
         q=p;
         p=p->first; // p指向将与K.ch[i+1]比较的结点
         ++i;
       }//if
       else // 没找到,插入关键字
       {
         ap=(DLTree)malloc(sizeof(DLTNode));
         if(q->first==p)
           q->first=ap; // 在长子的位置插入
         else // q->next==p;
           q->next=ap; // 在兄弟的位置插入
         ap->next=p;
         ap->symbol=K.ch[i];
         ap->kind=BRANCH;
         p=ap;
         i++;
         ap=(DLTree)malloc(sizeof(DLTNode));

         for(;i<K.num;i++) // 插入分支结点
         {
           p->first=ap;
           ap->next=NULL;
           ap->symbol=K.ch[i];
           ap->kind=BRANCH;
           p=ap;
           ap=(DLTree)malloc(sizeof(DLTNode));
         }//for

         p->first=ap; // 插入叶子结点
         ap->next=NULL;
         ap->symbol=Nil;
         ap->kind=LEAF;
         ap->infoptr=r;
       }//else
     }//while
   }//else
 }//InsertDSTable

 //如下为对栈的操作
Status InitStack(SqStack &S)
 { // 构造一个空栈S
   if(!(S.base=(SElemType *)malloc(STACK_INIT_SIZE*sizeof(SElemType))))
     exit(-1); // 存储分配失败
   S.top=S.base;
   S.stacksize=STACK_INIT_SIZE;
   return OK;
 }

 Status DestroyStack(SqStack &S)
 { // 销毁栈S，S不再存在
   free(S.base);
   S.base=NULL;
   S.top=NULL;
   S.stacksize=0;
   return OK;
 }

 Status ClearStack(SqStack &S)
 { // 把S置为空栈
   S.top=S.base;
   return OK;
 }

 Status StackisEmpty(SqStack S)
 { // 若栈S为空栈，则返回TRUE，否则返回false
   if(S.top==S.base)
     return true;
   else
     return false;
 }

 int StackLength(SqStack S)
 { // 返回S的元素个数，即栈的长度
   return S.top-S.base;
 }

 Status GetTop(SqStack S,SElemType &e)
 { // 若栈不空，则用e返回S的栈顶元素，并返回OK；否则返回ERROR
   if(S.top>S.base)
   {
     e=*(S.top-1);
     return OK;
   }
   else
     return ERROR;
 }

 Status Push(SqStack &S,SElemType e)
 { // 插入元素e为新的栈顶元素
   if(S.top-S.base>=S.stacksize) // 栈满，追加存储空间
   {
     S.base=(SElemType *)realloc(S.base,(S.stacksize+STACKINCREMENT)*sizeof(SElemType));
     if(!S.base)
       exit(-1); // 存储分配失败
     S.top=S.base+S.stacksize;
     S.stacksize+=STACKINCREMENT;
   }
   *(S.top)++=e;
   return OK;
 }

 Status Pop(SqStack &S,SElemType &e)
 { // 若栈不空，则删除S的栈顶元素，用e返回其值，并返回OK；否则返回ERROR
   if(S.top==S.base)
     return ERROR;
   e=*--S.top;
   return OK;
 }

 Status StackTraverse(SqStack S,Status(*visit)(SElemType))
 { // 从栈底到栈顶依次对栈中每个元素调用函数visit()。
   // 一旦visit()失败，则操作失败
   while(S.top>S.base)
     visit(*S.base++);
   printf("\n");
   return OK;
 }

 void TraverseDSTable(DLTree DT,void(*Vi)(Record))
 { // 初始条件: 双链键树DT存在，Vi是对结点操作的应用函数，
   //           ViR是对记录操作的应用函数
   // 操作结果: 按关键字的顺序输出关键字及其对应的记录
   //我们用

   SqStack s;
   SElemType e;
   DLTree p;
   int i=0,n=8;
   if(DT)
   {
         InitStack(s);
         e.p=DT;
         e.ch=DT->symbol;
         Push(s,e);        //根结点入栈
         p=DT->first;

         while(p->kind==BRANCH) // 分支结点
         {
               e.p=p;
               e.ch=p->symbol;
               Push(s,e);// 分支结点入栈
               p=p->first;
         }//while

         e.p=p;
         e.ch=p->symbol;    //Nil
         Push(s,e);// 叶子结点入栈

         Vi(*(p->infoptr));        //print
         i++;

         while(!StackisEmpty(s))
         {
                 //广度优先进行遍历
               Pop(s,e);
               p=e.p;
               if(p->next) // 有兄弟结点
               {
                     p=p->next;
                     while(p->kind==BRANCH) // 分支结点
                     {
                           e.p=p;
                           e.ch=p->symbol;
                           Push(s,e);            // 分支结点入栈
                           p=p->first;
                     }//while
                     e.p=p;
                     e.ch=p->symbol;

                     Push(s,e);// 叶子结点入栈
                     Vi(*(p->infoptr));
                     i++;

                     if(i%n==0)
                       printf("\n"); // 输出n个元素后换行
                }//if
        }//while
   }//if(DT)
 }//TraverseDSTable

void INputD(DLTree &t,Record r[])
{
    Record *p;   
    for(int i=0;i<N;i++)
       {
         r[i].key.num=strlen(r[i].key.ch);
         p=SearchDLTree(t,r[i].key);
         if(!p) // t中不存在关键字为r[i].key的项
            InsertDSTable(t,&r[i]);
       }//for
}//INputD

void UserSearch(DLTree t)
{
    char s[MAXKEYLEN+1];      
    Record *p;
    KeysType k;
    printf("\n请输入待查找记录的关键字符串: ");
    scanf("%s",s);
    k.num=strlen(s);
    strcpy(k.ch,s);
    p=SearchDLTree(t,k);
    if(p)
        print(*p);
    else
        printf("没找到");
    printf("\n");
}//UserSearch

int main()
{
    DLTree t;
    Record r[N]={    {{"CAI"},1},{{"CAO"},2},{{"LI"},3},{{"LAN"},4},

                    {{"CHA"},5},{{"CHANG"},6},{{"WEN"},7},{{"CHAO"},8},

                    {{"YUN"},9},{{"YANG"},10},{{"LONG"},11},{{"WANG"},12},

                    {{"ZHAO"},13},{{"LIU"},14},{{"WU"},15},{{"CHEN"},16}    };

    InitDSTable(t);
    INputD(t,r);
    printf("按关键字符串的顺序遍历双链键树:\n");
    TraverseDSTable(t,print);
    UserSearch(t);
    DestroyDSTable(t);

return 1;   
}