2023年华中科技大学计算机学院数据结构实验报告

课程实验报告

课程名称:数据结构实验

专业班级：计算机___________________

学号：___________________________

姓名：___________________________

指导教师:___________________________

报告日期：2023年1月6日

计算机科学与技术学院

目录

1基于顺序存储结构实现线性表的基本运算错误!未定义书签。

1.1实验目的。错误!未定义书签。

1.2线性表演示系统设计。错误!未定义书签。

1.2.1系统总体设计。错误!未定义书签。

1.2.2有关常量和类型定义。错误!未定义书签。

1.2.3算法设计错误!未定义书签。

1.3线性表演示系统实现与测试。错误!未定义书签。

1.3.1系统实现错误!未定义书签。

1.3.2系统测试。错误!未定义书签。

1.4实验小结。错误!未定义书签。

2基于链式实现线性表的基本运算错误!未定义书签。

2.1问题描述错误!未定义书签。

2.2线性表演示系统设计。错误!未定义书签。

2.2.1系统总体设计错误!未定义书签。

2.2.2有关常量和类型定义。错误!未定义书签。

2.2.3算法设计。错误!未定义书签。

2.3线性表演示系统实现与测试。错误!未定义书签。

2.3.1系统实现错误!未定义书签。

2.3.2系统测试。错误!未定义书签。

2.4实验小结。错误!未定义书签。

3基于顺序存储结构实现栈的基本运算错误!未定义书签。

3.1实验目的。错误!未定义书签。

3.2栈演示系统设计。错误!未定义书签。

3.2.1系统总体设计。错误!未定义书签。

3.2.2算法实现错误!未定义书签。

3.3栈演示系统实现与测试。错误!未定义书签。

3.3.1程序实现。错误!未定义书签。

3.3.2系统测试。错误!未定义书签。

3.4实验小结错误!未定义书签。

4基于循环队列存储结构实现队列的基本运算。错误!未定义书签。

4.1问题描述。错误!未定义书签。

4.2.1系统总体设计错误!未定义书签。

4.2.2有关常量和类型定义。错误!未定义书签。

4.2.3算法设计。错误!未定义书签。

4.3队列演示系统实现与测试。错误!未定义书签。

4.3.1系统实现。错误!未定义书签。

4.3.2系统测试。错误!未定义书签。

4.4实验小结错误!未定义书签。

5基于二叉链表实现二叉树的基本运算错误!未定义书签。

5.1实验目的错误!未定义书签。

5.2.1系统总体设计。错误!未定义书签。

5.2.2有关常量和类型定义。错误!未定义书签。

5.2.3算法设计错误!未定义书签。

5.3二叉树演示系统实现与测试。错误!未定义书签。

5.3.1系统实现错误!未定义书签。

5.3.2系统测试错误!未定义书签。

5.4实验小结。错误!未定义书签。

6基于邻接表实现图的基本和常见运算错误!未定义书签。

6.1实验目的。错误!未定义书签。

6.2.1系统总体设计。错误!未定义书签。

6.2.2有关常量和类型定义。错误!未定义书签。

6.2.3算法设计。错误!未定义书签。

6.3图演示系统实现与测试错误!未定义书签。

6.3.1系统实现错误!未定义书签。

6.3.2系统测试错误!未定义书签。

6.4实验小结。错误!未定义书签。

参考文献错误!未定义书签。

0

1基于顺序存储结构实现线性表的基本运算

1.1实验目的

。通过实验达成：（1）加深对线性表的概念、基本运算的理解；（2）纯熟掌握线性

表的逻辑结构与物理结构的关系；（3）物理结构采用顺序表,纯熟掌握线性表的基

本运算的实现。

1.2线性表演示系统设计

1.2.1系统总体设计

本系统提供一个顺序存储的线性表。

该演示系统提供的操作有:表的初始化、销毁、清空、判空，求表长、获取数

据元素、查找数据元素、获得前驱、获得后继、创建线性表、插入数据元素、删

除数据元素、表的遍历。

在程序中实现消息解决，涉及数据的输入和输出,程序的退出。

1.2.2有关常量和类型定义

数据元素类型的定义：

typedefintstatus;

typedefintElemType；

有关常量的定义：

#defineTRUE1

#defineFALSE0

#defineOK1

#defineERRORO

#defineINFEASTABLE-1

#defineOVERFLOW-2

#defineLISTINITSIZE100

#defineLISTINCREMENT10

1.2.3算法设计

(1)InitaList(&L)

操作结果：构造一个空的线性表。

(2)DestroyList(&L)

初始条件:线性表L已存在。

。操作结果：销毁线性表L。

⑶ClearList(&L)

。初始条件：线性表L已存在。

操作结果：将L重置为空表。

(4)ListEmpty(L)

。初始条件：线性表L已存在。

操作结果：若L为空表，则返回TRUE,否则返回FALSE。

(5)ListLength(L)

初始条件：线性表已存在。

操作结果:返回L中数据元素的个数。

(6)GetElem(L,i,&e)

初始条件:线性表已存在，1近iWListLength(L)。

操作结果:用e返回L中第i个数据元素的值。

(7)LocateElem(L,e,compare())

。初始条件:线性表已存在。

操作结果:返回L中第1个与e满足关系compare()关系的数据元素的

。。。位序，若这样的数据元素不存在，则返回值为0。

(8)PriorElem(L,cur_e,&pre_e)

。初始条件：线性表L已存在。

。操作结果:若cur_e是L的数据元素，且不是第一个，则用pre_e返回它的

。。前驱，否则操作失败,Pre_e无定义。

(9)NextE1em(L,cur_e,&next_e)

。初始条件：线性表L已存在。

操作结果：若cur_e是L的数据元素，且不是最后一个，则用next_e返回

它

。。的后继，否则操作失败,next_e无定义。

(10)Listinsert(&L,i,e)

。初始条件：线性表L已存在且非空，1WiWListLength(L)+l。

操作结果：在L的第i个位置之前插入新的数据元素e,L的长度加1

(11)ListDelete(&L,i,&e)

。初始条件：线性表L已存在且非空，iWiWListLength(L)。

操作结果:删除L的第i个数据元素，用e返回其值,L的长度减1.

(12)ListTraverse(L,visit())

初始条件：线性表L已存在。

。操作结果:依次对L的每个数据元素调用函数visit。。一旦调用失败，则操

作失败。

1.3线性表演示系统实现与测试

1.3.1系统实现

编程环境为VisualStudio2023,程序清单如下：

#define_CRT_SECURE_N0_WARNINGS

/*LinearTable0nSequenceStructure*/

#inc1ude<stdio.h>

#include<ma11oc.h>

#include<stdlib.h>

/*--page10ontextbook-——*/

#defineTRUE1

#defineFALSE0

#defineOK1

#defineERROR0

#defineINFEASTABLE-1

#defineOVERFLOW-2

typedefintstatus;

typedefintElemType;//数据元素类型定义

ooo/*page22ontextbook--*/

#defineLISTJNIT_SIZE100

#defineLISTINCREMENT10

typedefstruct{//顺序表(顺序结构)的定义

。ElemType*e1em;

intlength;

intlistsize;

}SqList；

/*page19ontextbook*/

statusIntiaList(SqList&L);

statusDestroyList(SqList*L);

statusCiearList(SqList&L);

statusListEmpty(SqListL);

intListLength(SqListL);

statusGetElem(SqListL,inti,ElemType&e);

intLocateElem(SqListL,ElemTypee);〃简化过

statusPriorElem(SqListL,ElemTypecue,E1emType*pre);

statusNextElem(SqListL,E1emTypecue,ElemType*next);

statusListlnsert(SqList*L,inti,ElemTypee)；

statusListDelete(SqList*L,inti,E1emType*e);

statusListTrabverse(SqListL);〃简化过

ElemTypee;

*/

voidmain(void){

SqListL;

“ntop=1,e,cue,pre,next,m；

while(op){

gsystem("cls");

。叩rintf(”\n\n");

。printf(nMenufbrLinearTableOnSequenceStructure

\n“)；

6printf("-——————\n");

oprintf(M1%IntiaList7.LocateElem\nn);

printf(n2.DestroyList8.PriorElem\nn);

printf(u3.C1earList9.NextE1em\

nM)；

ooprintf("4.ListEmpty10.ListInsert\nn);

eprintf(n5ListLength11.ListDelete\nn);

oprintf("6.GetElem12.ListTrabverse\n")；

。printf("0».Exit\n");

°printf(n———--―—---——\n")；

叩rintf("请选择你的操作[0-12]:")；

。scanf(n%d”，&op);

®switch(op)

(

。。case1:

//printf("\n■一—IntiaList功能待实现!\nH);

一(IntiaList(L)==OK)printf("线性表创建成功!\n");

。elseprintf("线性表创建失败!\n”);

o^getchar()；getchar();

sbreak;

&case2:

^//printf(n\n——DestroyList功能待实现！\nn);

。if(DestroyList(&L)==OK)printf("线性表销毁成功!\n”)；

。eIseprintf("线性表销毁失败!'n");

ggetchar()；getchar()；

sbreak；

®case3：

W/printf("\n——C1earList功能待实现!\n”)；

“if(C1earList(L)==OK)printf("线性表清空成功！\n”)；

gelseprintf("线性表清空失败！\nn);

ooogetchar();getchar()；

。®break;

case4：

00//printf(H\n——ListEmpty功能待实现!\n");

“if(ListEmpty(L)==OK)printf("线性表已清空！\n”)；

“eelseprintf(M线性表未清空!\n“)；

。®getchar()；getchar();

o^break;

。case5:

o“/printf("\n--—・ListLength功能待实现！\nu);

printf("线性表长度为%d\nListLength(L));

。getchar()；getchar();

break；

8case6:

”//printf("\n---GetElem功能待实现!\n”)；

^inti;

?叩rintf("请输入要查询的序数:")；

“scanf("％d”,&i);

gif(GetElem(L,i,e)==0K)printf(”表中第％d个数据为％小口”，i,

e);

elseprintf("查询失败!\n")；

getchar();getchar();

^break;

case7：

//printf(n\n-LocateElem功能待实现!\n”)；

printf("请输入要查询的数据:\n");

scanf(n%dH,&e)；

8m=LocateE1em(L,e);

if(m!=ERROR)

000

叩rintf("L中第一个与查询数据相等的数据的位序为％d\nm);

«<>else

。。printf(H这样的数据元素不存在！\n”)；

。getchar();getchar()；

力reak;

。。case8：

叩rintf("请输入要查询的元素：”);

。scanf(H%d&cue);

Af(PriorElem(L,cue,&pre)==OK)printf("前驱为％d\n”,pre);

8elseprintf("无此前驱\nn)；

8getchar();getchar();

。break;

case9：

printf("请输入要查询的元素：”)；

空canf("％d"，&cue);

。if(NextE1em(L,cue,&next)==OK)printf(n后驱为％d\n”,

next);

elseprin1」无此后驱\11");

80getchar();getchar();

由reak;

。case10:

。叩rintf("请输入i:n)；

。^scanfC'%d"，&i);

egprintf("请输入e:M)；

“scanf("％d"，&e);

。if(Listlnsert(&L,i,e)==OK)printf("线性表插入成功\n");

e1seprintf("线性表插入失败\n")；

。getchar();getchar();

3break;

。case11:

“printf("请输入要删除的元素的序列：”)；

08scanf(n%d”，&i);

Mf(ListDelete(&L,i,&e)==OK)printf("元素删除成功\n”)；

eIseprintf(n元素删除失败\n”);

o唱etchar();getchar();

3dbreak；

gcase12：

e//printf(M\n-——ListTrabverse功能待实现！\n”)；

if(!ListTrabverse(L))printf(”线性表是空表!\n")；

®getchar();getchar();

ebreak；

8case0:

break;

g}〃endofswitch

}//endofwhile

oprintf("欢迎下次再使用本系统!\n");

}//endofmain()

/*--—page23ontextbook————*/

statusIntiaList(SqList&L)

L.e1em=(E1emType*)ma11oc(L1ST_INIT_SIZE*sizeof

(E1emType));

oif(!L.e1em)exit(OVERFLOW);

L.length=0;

oL.listsize=LIST_INIT_SIZE;

«»returnOK;

)

statusDestroyList(SqList*L)

(

ofree(L—>e1em);

L->elem=NULL;

^returnOK;

)

statusC1earList(SqList&L)

(

1.length=0;

returnOK;

statusListEmpty(SqListL)

“f(L.1ength==0)

returnTRUE；

oeIse

<>returnERROR；

)

}//判断表空

intListLength(SqListL)

(

returnL.1ength；

)

statusGetE1em(SqListL,inti,E1emType&e)

(

»e=*(L.elem+i-1);

»returne；

}

intLocateElem(SqListL,E1emTypee)

(

“ntk=1;

♦while(*L.e1em!=e)

°(

。L.elem++;

k++;

if(k>L.length)

returnERROR；

returnk；

)

statusPriorElem(SqListL,ElemTypecue,ElemType*pre)

(

“nti;

for(i=1;i<L.1istsize;i++)

(

(L.elem[i]==cue)

6{

8*pre=(int)L.e1em[i-1];

6returnOK;

8}

)

returnFALSE;

}

statusNextElem(SqListL,ElemTypecue,E1emType*next)

(

。intm；

©for(m=0；m<L.listsize-1;m++)

。if(L.elem[m]==cue)

80*next=(int)L.elem[m+1];

8returnOK；

)

)

^returnFALSE；

)

statusListInsert(SqList*L,inti,E1emTypee)

(

oElemType*nw,*t,*p;

if(!L->elem)returnERROR;

oif(i<1||i>L->length+l)returnERR0R;

。if(L->length>=L->listsize)

。｛

»nw=(ElemType*)realloc(L->elem,(L—>1istsize+LISTIN

CREMENT)*sizeof(ElemType));

。if(!nw)retumERROR;

0L->elem=nw；

oL->listsize+=LISTINCREMENT;

)

4=&(L->elemLi-1])；

©for(p=&(L—>elem[L->length-11);p>=t；p—)

(

b*(p+1)=*P；

0)

0*t=e;

++L—>length;

^returnOK;

}

statusListDelete(SqList*L,inti,ElemType*e)

(

•ElemType*t,*p；

if(i<1I|i>L—>1ength|I!L->e1em)returnERROR;

叩=&(L->e1em[i-1]);

e=p；

“二&(L—>e1em[L->length-1]);

ofor(p++;pv=t；++p)

8*(p-1)=*p；

--L->1ength;

returnOK;

)

statusListTrabverse(SqListL)

{

，inti;

printf(”\n——al1elements—■

—\n");

for(i=0；i<L.length;i++)printf("%d",L.elem[_i]);

printf(u\n——---end----\nH)；

retumL.1ength;

)

1.3.2系统测试

表1一1线性表算法测试用例表

测试用例程序输入理论结果运行结果

用例11线性表创建成功线性懒器作皿

用例22线性表销毁成功卜疆螂作

用例3线性表清空成功适选择便的操作［歹12］：3

3怦性表清空成功！

F_______________________________1

用例44线性表已清空

遣选!至你的操作

线性袤已清空！

用例55线性表长度为0谓选择你的操作［0~121：5

线性袤长度为。

用例66表中第1个数据为1

翻请翻选择你球的操嬴作1

表中第一个与查询数据相等的道选择侵的盘作■12】:7

用例77，青输入要查询的数据，

1中第一个与查询数据檐的故据的位序为1

数据的位序为1

前驱为

用例885L4请选操你的操作］：8

馆输入要查曾的元素：2

单I为5

用例99后驱为1

请选择你的提隹［0~12「9

道输△要查询的元象2

后驱为工

用例1010线性表插入成功清欠选择你的操作［0~123：10

礴入e；9

线程表插入成功

用例1111元素删除成功请选择你的操作［。~12］：11

请输人要剧除的元素的用如1

元差躺除成功

用例1212521请选择你的操作【。~12］：12

allelenents

521

end

1.4实验小结

这是第一次数据结构的实验，实验完毕期间恰逢离散和复变的考试,复习与

实验一起进行让我压力不小。好在老师有针对性的在课堂上指点了很多关键点,

让我的实验顺利进行。本次实验加深了我对*L和&L的理解，代码中仍有不尽如

人意的地方,相信以后会做的越来越好。

2基于链式实现线性表的基本运算

2.1问题描述

。通过实验达成：（1）加深对线性表的概念、基本运算的理解;（2）纯熟掌握线性

表的逻辑结构与物理结构的关系；（3）物理结构采用带表头结点的单链表，纯熟

掌握线性表基本运算的实现。

2.2线性表演示系统设计

2.2.1系统总体设计

本系统提供一个链式存储的线性表。

该演示系统提供的操作有:表的初始化、销毁、清空、判空，求表长、获取

数据元素、查找数据元素、获得前驱、获得后继、创建线性表、插入数据元素、

删除数据元素、表的遍历。

在程序中实现消息解决，涉及数据的输入和输出,程序的退出。

2.2.2有关常量和类型定义

数据元素类型的定义：

typedefintstatus;

typedefintElemType；

有关常量的定义：

#defineTRUE1

#defineFALSE0

#defineOK1

#defineERROR0

#defineINFEASTABLE-1

#defineOVERFLOW-2

#defineLIST_INIT_SIZE100

#defineLISTINCREMENT10

2.2.3算法设计

(1)InitaList(&L)

。操作结果:构造一个空的单链表。

(2)DestroyList(&L)

初始条件：单链表L已存在。

操作结果:销毁单链表L。

(3)ClearList(&L)

初始条件:单链表L已存在。

操作结果：将L重置为空单链表。

(4)ListEmpty(L)

初始条件：单链表L已存在。

。操作结果：若L为空单链表,则返回TRUE,否则返回FALSE.

(5)ListLength(L)

初始条件：单链表已存在。

。操作结果：返回L中数据元素的个数。

(6)GetElem(L,i,&e)

。初始条件：单链表已存在，iWiWListLength(L)。

。操作结果：用e返回L中第i个结点的数据元素值。

(7)LocateElem(L,e,compare())

初始条件：单链表已存在。

。操作结果：返回L中第1个与e满足关系compare()的数据元素结点的指

。。。针，若这样的数据元素不存在，则返回值为NULL。

(8)PriorElem(L,cur_e,&pre_e)

初始条件:单链表L已存在。

。操作结果：若cur_e是L的数据元素，且不是第一个，则用pre_e返回它的

。前驱，否则操作失败,pre_e无定义。

(9)NextElem(L,cur_e,&next_e)

初始条件:单链表L已存在。

。操作结果：若cur_e是L的数据元素，且不是最后一个，则用next_e返回它

。。8的后继，否则操作失败,next_e无定义。

(10)ListInsert(&L,i,e)

。初始条件：单链表L已存在且非空，iWiWListLength(L)+lo

操作结果:在L的第i个结点之前插入新数据元素e的结点。

(ll)ListDe1ete(&L,i,&e)

初始条件：单链表L已存在且非空,1WiWListLength(L)。

。操作结果：删除L第i个数据元素的结点，用e返回其结点数据元素的值。

(12)ListTraverse(L,visit())

初始条件：单链表L已存在。

。操作结果：依次对L的每个数据元素调用函数visit()。一旦调用失败，则操

88作失败。

2.3线性表演示系统实现与测试

2.3.1系统实现

编程环境为VisualStudio2023,程序清单如下：

#define_CRT_SECURE_NO_WARNINGS

/*LinearTableOnSequeneeStructure*/

#inc1ude<stdio.h>

#include<malloc.h>

#include<stdlib.h>

/*--page10ontextbook——一一一*/

#defineTRUE1

#defineFALSEO

#defineOK1

#defineERROR0

#defineINFEASTABLE-1

#defineOVERFLOW-2

typedefintstatus;

typedefintElemType;//数据元素类型定义

oo/*——---page22ontextbook—*/

#defineLIST_INIT_SIZE100

#defineLISTINCREMENT10

typedefstructListNode{//顺序表(顺序结构)的定义

ElemTypedata;

structListNode*next;

}ListNode,*pListNode;

inte;

ListNodeL；

pListNodepL=&L;

statusIntiaList(pListNode&Lp){

eLp=(pListNode)ma11oc(sizeof(ListNode));

Lp->data=0;

©Lp->nextNULL;

pL=Lp;

returnOK；

}

statusDestroyList(pListNode&Lp){

if(!Lp)returnERROR;

Lp—>data=0;

if(Lp->next==NULL)

。{

ofree(Lp->next);

。free(Lp);

)

吒1se

。{

。DestroyList(Lp—>next)；

Lp->next=NULL；

efree(Lp);

}

return0K;

)

statusC1earList(pListNode&Lp){

if(!Lp)returnERROR;

Lp—>data=0；

if(Lp->next==NULL)

近ee(Lp);

else

°(

eClearList(Lp—>next);

^free(Lp);

)

returnOK;

)

statusListEmpty(ListNodeL){

。if(L.data==0)

eturnTRUE;

吒Ise

8returnFALSE;

)

intListLength(ListNodeL){

returnL.data；

)

statusGetElem(ListNodeL,nti,ElemType*e)

if(i<l|Ii>L.data)

ereturnERROR;

叩ListNodep=L.next;

。while(-i)

p=p->next;

o}

°(*e)=p->data；

©returnOK；

statuscompare(ElemTypee,ElemTypef)

(

oif(f==e)returnTRUE;

oelsereturnFALSE;

)

statusLocateE1em(ListNodeL,ElemTypeestatus(*compa

rep)(E1emTypee,ElemTypef))

(

if(L.next==NULL)

greturnERROR;

pListNodep=L.next;

。inti=1;

while(p)

»if((*comparep)(e,p->data))

returni;

®else

°i++;

eP-p->next;

00|

°)

oreturn0;

)

statusPriorElem(ListNodeL,ElemTypecur_e,E1emType*pre

e)

(

^»if(L.data==0)

returnERROR;

if(L.next—>data=cur_e)

returnERROR;

叩ListNodepri_p=L.next,cur_p=L.next->next；

while((cur_p->data!=cur_e)&&cur_p)

b{

opri—p=cur_p；

8cur_p=cur_p->next;

)

if(cur_p->data==cur_e)

{

e*pre_e=pri_p->data;

returnOK;

0)

®elsereturnERROR;

statusNextE1em(ListNodeL,ElemTypecur_e,E1emType*next

e)

(

if(L.next==0)

oreturnERROR；

pListNodep=L.next;

while(p->data!=cur_e&&p->next)

。p=p->next;

if(!(P->next))returnERROR;

®else//if(p->data==cur_e)

{

g*next_e=p->next->data；

returnOK;

statusListlnsert(pListNodeLp,inti,E1emTypee){

“f(i<l||i>Lp->data+1)

。returnERROR;

叩ListNodep=(pListNode)malloc(sizeof(ListNode));

if(Lp->data==0){

Lp—>next=p；

p->data=e；

。叩―>next=NULL;

。Lp->data=1;

returnOK；

°)

pListNodepl=Lp->next;

whi1e(pl->next)pl=pl->next;

p1—>next=p；

叩,data=e;

p->next=NULL;

Lp->data++;

retumOK;

)

statusListDe1ete(pListNodeLp,inti,ElemType*e)

(

if(Lp->data)

。{

•if(iV1I|i>Lp->data)

。«>returnERROR;

8PListNodep1=Lp,p2=Lp->next;

^intj=1;

owhile(p2&&j<i)

{

。。p1二p2；

。。叩2=p2->next；

j++;

»}

pl->next=p2->next；

*ep2->data;

。Lp->data—;

free(p2);

8returnOK;

}

o「eturnERROR；

)

voidvisit(E1emTypee,inti){

printf("对第%d个元素调用visit函数:元素值为％d\n\n",i+1,e);

)

statusListTrabverse(ListNodeL,void(*visitp)(ElemTypee,i

nti))

(

if(!L.data)returnERROR；

。pListNodep=L.next;

inti=0;

叩rintf("\n——对所有元素调用函数visit-----------

-\n");

°while(p)/〃依次对每个元素调用visit函数

(

g(*visitp)(p—>data,i++);

op=p->next；

)

oprintf("\n---end---————\n");

retumOK；

)

/*_-_—_____一—一__—__—_一一__—_———__—,-*/

voidmain(void){

ointop=1,e,cue,pre,next,m;

awhile(op){

system(ncIsn)；

oprintf(M\n\nn);

printf(uMenuforLinearTableOnSequenceStructu

re\nu)；

printf(n——————\n");

sprintf(n。1.IntiaList7.LocateElem\nn);

sprintf(“。2.DestroyList8.PriorE1em\n");

printf(n3.CiearList9.NextElem\nn)；

printf(M4.ListEmpty10.ListInsert\n")；

oprintf("5ListLength11.ListDelete\nn)；

gprintf("36.GetElem12.ListTrabverse\n");

。printf(M。0.Exit\nn);

■\nn)；

printf("请选择你的操作[0~12]:");

seanf("％d"，&op);

^switch(op)

gcase1：

g//printf("\n——IntiaList功能待实现!\n”);

if(IntiaList(pL)==OK)printf("线性表创建成功!

\n")；

。eIseprintf(H线性表创建失败！\nn);

。getchar();getchar();

gbreak;

ocase2：

g//printf("\n--DestroyList功能待实现!\n”)；

oooif(DestroyList(pL)==OK)printf(H线性表销毁成功！\n“)；

匕elseprintff线性表销毁失败！\n”)；

。<>getchar();getchar();

sbreak;

^case3:

n

ooo//printfC\n--CiearList功能待实现!\n);

if(ClearList(pL)==OK)printf("线性表清空成功!\n")；

3e1seprintf("线性表清空失败!\nn);

。getchar();getchar();

“break;

case4：

。//printf(H\n----ListEmpty功能待实现!\n”);

if(ListEmpty(L)==OK)printf("线性表已清空！\n”)；

。elseprintf("线性表未清空!\n”)；

“getchar();getchar();

3break;

ocase5：

00//printf("\n-一一-ListLength功能待实现!\n");

。。printf("线性表长度为％d\n",ListLength(L))；

“getchar();getchar();

。break;

“case6：

。//printf("\n--GetElem功能待实现!\n");

。inti;

。printf("请输入要查询的序数：")；

“scanf("%d",&i);

“if(GetElem(L,i,&e)==0K)printf("表中第％d个数据为％

d\n",i,e)；

ooelseprintf("查询失败！\n");

ggetchar();getchar();

break；

»case7：

ooo//printf("\n-LocateElem功能待实现!\n");

printf("请输入要查询的数据:\n")；

。scanf("%d",&e);

。=LocateElem(L,e,compare)；

。if(m!=ERROR)

0{

3叩rintf("L中第一个与查询数据相等的数据的位序为％d\n"，m)；

»}

e1se

。I

如printf（"这样的数据元素不存在！\n"）;

00

ogetchar();getchar()；

8bbreak;

case8：

，叩rintf("请输入要查询的元素：")；

scanf('*%d”,&cue);

“if(Prior