#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;
}
