数据结构 设计性实验 广义表的抽象数据类型.docx

1、数据结构 设计性实验 广义表的抽象数据类型题目：广义表的抽象数据类型抽象数据类型广义表的定义基本操作:InitGList(&L);操作结果：创建空的广义表L。CreateGList(&L,S);初始条件：S是广义表的书写形式串。操作结果：由S创建广义表L。DestroyGList(&L);初始条件：广义表L存在。操作结果：销毁广义表L。CopyGList(&T,L);初始条件：广义表L存在。操作结果：由广义表L复制得到广义表T。GlistLength(L);初始条件：广义表L存在。操作结果：求广义表L的长度，即元素个数。GlistDepth(L);初始条件：广义表L存在。操作结果：求广义表的深

2、度。GlistEmpty(L);初始条件：广义表L存在。操作结果：判定广义表L是否为空。GetHead(L);初始条件：广义表L存在。操作结果：取广义表L的头。GetTail(L);初始条件：广义表L存在。操作结果：取广义表L的尾。InsertFirst_GL(&L,e);初始条件：广义表L存在。操作结果：插入元素e作为广义表L的第一元素。DeleteFirst_GL(&L,&e);初始条件：广义表L存在。操作结果：删除广义表L的第一元素，并用e返回其值。Traverse_GL(L,Visit();初始条件：广义表L存在。操作结果：遍历广义表L，用函数Visit处理每个元素。ADT 存储结构定

3、义由于广义表中的数据元素可以具有不同的结构，（或是原子，或是列表），因此难以用顺序存储结构表示，通常有采用链式存储结构，每个数据元素可用一个结点表示。由于列表中的数据元素可能为原子或列表，由此需要两种结构的结点：一种是表结点,以表示列表；一种是原子结点，用以表示原子。若列不空，则可分解成表头和表尾；反之，一对确定的表头和表尾可唯一确定列表。由此，一个表结点可由三个域组成：标志域、指示域和指示表尾的指针域；而原子结点只需两个域：标志域和值域（如图8所示）。其形式定义说明如下： 存储结构: 公用头文件DS0.h: #include #include #include #include #inclu

4、de #include #include #include #include #define TRUE 1 #define FALSE 0 #define OK 1 #define ERROR 0 #define INFEASIBLE -1 typedef char AtomType; /* 定义原子类型为字符型 */ /-广义表的头尾链表存储表示-/typedef enumATOM,LISTElemTag;/ATOM= =0:原子，LIST= =1：子表typedef struct GLNodeElemTag tag; /公共部分，用于区分原子结点和表结点union /原子结点和表结点的联合

5、部分AtomType atom; /atom是原子结点的值域，AtomType由用户定义Structstruct GLNode *hp, *tp;ptr;/ptr是表结点的指针域，ptr.hp和ptr.tp分别指向表头和表尾； *Glist; /广义表类型 /-广义表的扩展线性链表存储表示-/typedef enumATOM,LISTElemTag; /ATOM= =0:原子，LIST= =1:子表typedef struct GLNodeElemTag tag; /公共部分，用于区分原子结点和表结点union /原子结点和表结点的联合部分AtomType atom; /原子结点的值域Stru

6、ct GLNode *hp; /表结点的表头指针；struct GLNode *tp; /相当于线性链表的next，指向下一个元素结点Glist; /广义表类型Glist是一种扩展的线性链表四, 算法设计#include #include #include #include #include #include #include #include #include #define TRUE 1 #define FALSE 0 #define OK 1 #define ERROR 0 #define INFEASIBLE -1 typedef char AtomType; /* 定义原子类型为字符

7、型 */ typedef int Status; /* Status是函数的类型,其值是函数结果状态代码，如OK等 */ typedef int Boolean; typedef struct char *ch; /* 若是非空串,则按串长分配存储区,否则ch为NULL */ int length; /* 串长度 */ HString; typedef enumATOM,LISTElemTag; /* ATOM=0:原子,LIST=1:子表 */ typedef struct GLNode ElemTag tag; union AtomType atom; struct GLNode *hp;

8、 a; struct GLNode *tp; *GList,GLNode; Status StrAssign(HString *T,char *chars) int i,j; if(*T).ch) free(*T).ch); i=strlen(chars); if(!i) (*T).ch=NULL; (*T).length=0; else /* chars的长度不为0 */ (*T).ch=(char*)malloc(i*sizeof(char); if(!(*T).ch) /* 分配串空间失败 */ exit(OVERFLOW); for(j=0;ji;j+) /* 拷贝串 */ (*T).

9、chj=charsj; (*T).length=i; return OK; Status StrCopy(HString *T,HString S) /* 初始条件:串S存在。操作结果: 由串S复制得串T */ int i; if(*T).ch) free(*T).ch); (*T).ch=(char*)malloc(S.length*sizeof(char); if(!(*T).ch) exit(OVERFLOW); for(i=0;iT,则返回值0;若S=T,则返回值=0;若ST,则返回值0 */ int i; for(i=0;iS.length&iT.length;+i) if(S.ch

10、i!=T.chi) return S.chi-T.chi; return S.length-T.length; int StrLength(HString S) /* 返回S的元素个数,称为串的长度 */ return S.length; Status ClearString(HString *S) /* 将S清为空串 */ if(*S).ch) free(*S).ch); (*S).ch=NULL; (*S).length=0; return OK; Status Concat(HString *T,HString S1,HString S2) /* 用T返回由S1和S2联接而成的新串 */

11、 int i; if(*T).ch) free(*T).ch); /* 释放旧空间 */ (*T).length=S1.length+S2.length; (*T).ch=(char *)malloc(*T).length*sizeof(char); if(!(*T).ch) exit(OVERFLOW); for(i=0;iS1.length;i+) (*T).chi=S1.chi; for(i=0;iS2.length;i+) (*T).chS1.length+i=S2.chi; return OK; Status SubString(HString *Sub, HString S,int

12、 pos,int len) /* 用Sub返回串S的第pos个字符起长度为len的子串。 */ /* 其中,1posStrLength(S)且0lenStrLength(S)-pos+1 */ int i; if(posS.length|lenS.length-pos+1) return ERROR; if(*Sub).ch) free(*Sub).ch); /* 释放旧空间 */ if(!len) /* 空子串 */ (*Sub).ch=NULL; (*Sub).length=0; else /* 完整子串 */ (*Sub).ch=(char*)malloc(len*sizeof(char

13、); if(!(*Sub).ch) exit(OVERFLOW); for(i=0;i0) n=StrLength(S); m=StrLength(T); i=pos; while(i=n-m+1) SubString(&sub,S,i,m); if(StrCompare(sub,T)!=0) +i; else return i; return 0; Status StrInsert(HString *S,int pos,HString T) /* 算法4.4 */ /* 1posStrLength(S)+1。在串S的第pos个字符之前插入串T */ int i; if(pos(*S).len

14、gth+1) /* pos不合法 */ return ERROR; if(T.length) /* T非空,则重新分配空间,插入T */ (*S).ch=(char*)realloc(*S).ch,(*S).length+T.length)*sizeof(char); if(!(*S).ch) exit(OVERFLOW); for(i=(*S).length-1;i=pos-1;-i) /* 为插入T而腾出位置 */ (*S).chi+T.length=(*S).chi; for(i=0;iT.length;i+) (*S).chpos-1+i=T.chi; /* 插入T */ (*S).l

15、ength+=T.length; return OK; Status StrDelete(HString *S,int pos,int len) /* 从串S中删除第pos个字符起长度为len的子串 */ int i; if(*S).lengthpos+len-1) exit(ERROR); for(i=pos-1;i=(*S).length-len;i+) (*S).chi=(*S).chi+len; (*S).length-=len; (*S).ch=(char*)realloc(*S).ch,(*S).length*sizeof(char); return OK; Status Repl

16、ace(HString *S,HString T,HString V) /* 初始条件: 串S,T和V存在,T是非空串（此函数与串的存储结构无关） */ /* 操作结果: 用V替换主串S中出现的所有与T相等的不重叠的子串 */ int i=1; /* 从串S的第一个字符起查找串T */ if(StrEmpty(T) /* T是空串 */ return ERROR; do i=Index(*S,T,i); if(i) StrDelete(S,i,StrLength(T); StrInsert(S,i,V); i+=StrLength(V); while(i); return OK; void D

17、estroyString() /* 堆分配类型的字符串无法销毁 */ void StrPrint(HString T) /* 输出T字符串。另加 */ int i; for(i=0;iT.length;i+) printf(%c,T.chi); printf(n); /* 广义表的书写形式串为HString类型 */ Status InitGList(GList *L) /* 创建空的广义表L */ *L=NULL; return OK; Status sever(HString *str,HString *hstr) /* 同bo5-52.c */ /* 将非空串str分割成两部分:hstr

18、为第一个,之前的子串,str为之后的子串 */ int n,i=1,k=0; /* k记尚未配对的左括号个数 */ HString ch,c1,c2,c3; InitString(&ch); /* 初始化HString类型的变量 */ InitString(&c1); InitString(&c2); InitString(&c3); StrAssign(&c1,); StrAssign(&c2,(); StrAssign(&c3,); n=StrLength(*str); do SubString(&ch,*str,i,1); if(!StrCompare(ch,c2) +k; else i

19、f(!StrCompare(ch,c3) -k; +i; while(i=n&StrCompare(ch,c1)|k!=0); if(itag=LIST; (*L)-a.hp=NULL; (*L)-tp=NULL; else if(StrLength(S)=1) /* 创建单原子广义表 */ (*L)-tag=ATOM; (*L)-a.atom=S.ch0; (*L)-tp=NULL; else /* 创建一般表 */ (*L)-tag=LIST; (*L)-tp=NULL; SubString(&sub,S,2,StrLength(S)-2); /* 脱外层括号 */ sever(&sub,

20、&hsub); /* 从sub中分离出表头串hsub */ CreateGList(&(*L)-a.hp,hsub); p=(*L)-a.hp; while(!StrEmpty(sub) /* 表尾不空,则重复建n个子表 */ sever(&sub,&hsub); /* 从sub中分离出表头串hsub */ CreateGList(&p-tp,hsub); p=p-tp; ; return OK; void DestroyGList(GList *L) /* 初始条件: 广义表L存在。操作结果: 销毁广义表L */ GList ph,pt; if(*L) /* L不为空表 */ /* 由ph和

21、pt接替L的两个指针 */ if(*L)-tag) /* 是子表 */ ph=(*L)-a.hp; else /* 是原子 */ ph=NULL; pt=(*L)-tp; free(*L); /* 释放L所指结点 */ *L=NULL; /* 令L为空 */ DestroyGList(&ph); /* 递归销毁表ph */ DestroyGList(&pt); /* 递归销毁表pt */ Status CopyGList(GList *T,GList L) /* 初始条件: 广义表L存在。操作结果: 由广义表L复制得到广义表T */ if(!L) /* L空 */ *T=NULL; retur

22、n OK; *T=(GList)malloc(sizeof(GLNode); if(!*T) exit(OVERFLOW); (*T)-tag=L-tag; /* 复制枚举变量 */ if(L-tag=ATOM) /* 复制共用体部分 */ (*T)-a.atom=L-a.atom; /* 复制单原子 */ else CopyGList(&(*T)-a.hp,L-a.hp); /* 复制子表 */ if(L-tp=NULL) /* 到表尾 */ (*T)-tp=L-tp; else CopyGList(&(*T)-tp,L-tp); /* 复制子表 */ return OK; int GLis

23、tLength(GList L) /* 初始条件: 广义表L存在。操作结果: 求广义表L的长度,即元素个数 */ int len=0; GList p; if(L-tag=LIST&!L-a.hp) /* 空表 */ return 0; /* 空表返回0 */ else if(L-tag=ATOM) /* 单原子表 */ return 1; else /* 一般表 */ p=L-a.hp; do len+; p=p-tp; while(p); return len; int GListDepth(GList L) /* 初始条件: 广义表L存在。操作结果: 求广义表L的深度 */ int ma

24、x,dep; GList pp; if(L=NULL|L-tag=LIST&!L-a.hp) return 1; /* 空表深度为1 */ else if(L-tag=ATOM) return 0; /* 单原子表深度为0 */ else /* 求一般表的深度 */ for(max=0,pp=L-a.hp;pp;pp=pp-tp) dep=GListDepth(pp); /* 求以pp为头指针的子表深度 */ if(depmax) max=dep; return max+1; /* 非空表的深度是各元素的深度的最大值加1 */ Status GListEmpty(GList L) /* 初始条件: 广义表L存在。操作结果: 判定广义表L是否为空 */ if(!L|L-tag=LIST&!L-a.hp) return OK; else return ERROR; GList GetHead(GList L) /* 初始条件: 广义表L存在。操作结果: 取广义表L的头 */ GList h; InitGList(&h); if(!L|L-tag=LIST&!L-