来自公众号：C语言与cpp编程

1线性表的基本概念

对于同一个线性表，其每一个数据元素的值虽然不同，但必须具有相同的数据类型；

数据元素之间具有一种线性的或“一对一”的逻辑关系；

第一个数据元素没有前驱，这个数据元素被称为开始节点；

最后一个数据元素没有后继，这个数据元素被称为终端节点；

除了第一个和最后一个数据元素外，其他数据元素有且仅有一个前驱和一个后继；

2线性表抽象数据类型描述

基本操作如下：

线性表的置空操作clear()：将一个已经存在的线性表置为空表；

线性表判空操作isEmpty()：判断线性表是否为空，若为空，则返回true；否则，返回为false；

求线性表的长度操作length()：求线性表中的数据元素的个数并返回其值；

取元素操作get(i)：读取并返回线性表中的第i个数据元素的值。其中i的取值范围为0≤i≤length()-1；

插入操作insert(i,x)：在线性表的第i个数据元素之前插入一个值为x的数据元素。其中i的取值范围为0≤i≤length()。当i=0时，在表头插入x；当i=length()时，在表尾插入x；

删除操作remove(i)：删除并返回线性表中第i个数据元素。其中i的取值范围为0≤i≤length()-1；

查找操作indexOf(x)：返回线性表中首次出现的指定的数据元素的位序号，若线性表中不包含此数据元素，则返回-1；

3线性表的顺序表示和实现3.1顺序表的定义

所谓顺序表就是顺序存储的线性表。顺序存储是用一组地址连续的存储单元依次存放线性表中各个元素的存储结构。

3.2顺序表的特点

在线性表中逻辑上相邻的数据元素，在物理存储上也是相邻的；

存储密度高，但要预先分配“足够应用”的存储空间，这可能会造成存储空间的浪费；

便于随机存储；

不便于插入和删除操作，这是因为在顺序表上进行的插入和删除操作会引起大量数据元素的移动；

3.3顺序存储结构类的描述

顺序表的存储结构示意图

为了用C语言描述上图的顺序表，定义结构体SeqList如下：

typedefstruct{DateTypedata[MAXSIZE];/*数组存储数据元素*/intsize;/*线性表当前长度*/}SqList;

【说明】：其中，DataType为数组元素（即数据元素）的数据类型，MaxSize表示数组的最大元素个数，list表示顺序表的数组成员，size表示顺序表中当前存储的数据元素个数成员，且必须满足条件size≤MaxSize，SeqList是结构体名。

3.4顺序表操作的实现

在顺序存储结构下，线性表抽象数据类型定义的各个操作的具体实现方法如下：

初始化ListInitiate(L)

voidListInitiate(SeqList*L)//初始化顺序表L{L-size=0;//定义初始化数据元素个数}

【说明】由于函数中要改变参数L的size域的值，所以参数L应设计为输出型参数，即参数L设计为SeqList的指针类型。否则，size域的修改值将不能带回去。

求当前数据元素个数ListLength(L)

intListInitiate(SeqListL)//返回顺序表L的当前数据元素个数{;}

插入数据元素ListInsert(L,i,x)

顺序表插入过程

代码实现：

intListInsert(SqList*L,inti,DateTypex){intk;if(L-size==MAXSIZE)/*顺序线性表已满*/{printf("顺序表已满无法插入！\n");return0;}if(i1||iL-size)/*i不在范围内*/{return0;}if(i=L-size-1)/*插入位置不在表尾*/{//从后向前依次后移数据，为插入做准备for(k=L-size;k=i-1;k--){L-list[k]=L-list[k-1];}}L-list[i]=x;//插入xL-size++;//元素个数加1return1;}

【说明】：

如果线性表长度大于等于数组长度，抛出异常

如果插入位置不合理，抛出异常

从最后一个元素开始向前遍历到第i个位置，分别将它们都向后移动一个位置

从最后一个元素开始向前遍历到第i个位置，分别将它们都向后移动一个位置

表长加1

删除数据元素ListDelete(L,i,x)

顺序表删除过程

代码实现：

intListDelete(SequenceList*L,inti,DateType*x){/*删除顺序表L中位置i（0≤i≤size-1）的数据元素值并存放到参数x中*//*删除成功返回1，删除失败返回0*/intj;if(L-size=0){printf("顺序表已空无数据元素可删!\n");return0;}elseif(i0||iL-size-1){printf("参数i不合法");return0;}else{*x=L-list[i];//保存删除的元素到参数x中//从i位置的后一位开始，依次往前移一位，直到最后for(j=i+1;j=L-size-1;j++){L-list[j-1]=L-list[j];}L-size--;//数据元素个数减1return1;}}

【说明】：

如果为空表，抛出异常

如果删除位置不合理，抛出异常

从删除元素位置开始遍历到最后一个元素位置，分别将它们向前移动一个位置

表长减1

取数据元素ListGet(L,i,x)

/*取顺序表L中第i个数据元素的值存于x中，成功则返回1，失败返回0*/intListGet(SequenceListL,inti,DateType*x){if(i0||){printf("参数i不合法!\n");return0;}else{*x=[i];return1;}}

实例设计

1、编程实现如下任务：建立一个线性表，首先依次输入数据元素1,2,3,…,10，然后删除数据元素5，最后依次显示当前线性表中的数据元素。假设该线性表的数据元素个数在最坏情况下不会超过100个。要求使用顺序表。

defineMaxSize100typedefintElemType;//包含exit()函数include""//包含单链表文件intmain(intargc,char*argv[]){SLNode*head;//定义头指针变量inti,x;ListInitiate(head);//初始化for(i=0;i10;i++)//插入10个数据元素{if(ListInsert(head,i,i+1)==0){printf("错误！\n");return;}}for(i=0;iListLength(head);i++)//显示当前的数据元素中的值{if(ListGet(head,i,x)==0)//取元素值到x变量中{printf("错误！\n");return;}else{printf("%d",x);//显示}}printf("\n");if(ListDelete(head,4,x)==0)//删除下标为四(值为5)的数据元素{printf("错误！\n");return;}for(i=0;iListLength(head);i++)//显示当前的数据元素中的值{if(ListGet(head,i,x)==0)//取元素值到x变量中{printf("错误！\n");return;}else{printf("%d",x);//显示}}printf("\n");Destroy(head);//撤消单链表return0;}

2、设头指针为head,并设带头结点单链表中的数据元素递增有序，编写算法将数据元素x插入到带头结点单链表的适当位置上，要求插入后保持单链表数据元素的递增有序。

代码如下：

voidLinListInsert(SLNode*head,DataTypex){SLNode*curr,*pre,*q;//循环初始化curr=head-next;//curr指向第一个数据元素结点pre=head;//pre指向头结点//循环定位插入位置while(curr!=NULLcurr-data=x){pre=curr;curr=curr-next;}//申请一个结点并把x存入data域if((q=(SLNode*)malloc(sizeof(SLNode)))==NULL)exit(1);q-data=x;//把新结点插入pre所指结点后q-next=pre-next;pre-next=q;}

3、设head为单链表的头指针，并设单链表带有头结点，编写算法将单链表中的数据元素按照其值递增有序的顺序进行就地排序。

代码如下：

voidLinListSort(SLNode*head){SLNode*curr,*pre,*p,*q;p=head-next;head-next=NULL;while(p!=NULL){curr=head-next;pre=head;while(curr!=NULLcurr-data=p-data){pre=curr;curr=curr-next;}q=p;p=p-next;q-next=pre-next;pre-next=q;}}

双向链表

和单向链表相比有以下优势：

插入删除不需要移动元素外，可以原地插入删除

可以双向遍历

结构体定义如下：

typedefstructNode{DateTypedata;structNode*next,*prior;}Node,*LinkList;

双向循环链表的操作实现：

在双向循环链表中，有如下指针关系：设指针p指向双向循环链表中的第i个结点，则p-next指向第i+1个结点，p-next-prior仍指向第i个结点，即p-next-prior==p；同样地，p-prior指向第i-1个结点，p-prior-next仍指向第i个结点，即p-prior-next==p。双向循环链表的上述指针关系可以方便算法设计。

双向循环链表指针关系

初始化

intInitList(DLNode**head){*head=(DLNode*)malloc(sizeof(DlNode));(*head)-prior=*head;(*head)-next=*head;return1;}

插入数据元素

和单链表相比，双向循环链表的插入算法指针p可以直接指在第i个结点上，而不需要让指针p指在第i-1个结点上。

双向循环链表的插入过程

删除数据元素

和单链表相比，双向循环链表的删除算法指针p可以直接指在第i个结点上，而不需要让指针p指在第i-1个结点上。

循环双向链表的删除过程

双向链表的C语言实现:

/*runthisprogramusingtheconsolepauseroraddyourowngetch,system("pause")orinputloop*///用到的库文件//exit()//srand((unsigned)time(NULL));//函数结果状态代码defineFALSE0defineERROR0defineOVERFLOW-2//Status是函数的类型，其值是函数结果状态代码typedefintStatus;//#defineElemTypeint//也可以用宏定义确定ElemType类型typedefintElemType;//-----双向链表-----typedefstructDuLNode{ElemTypedata;//数据域structDuLNode*prior;//指向前驱structDuLNode*next;//指向后继}DuLNode,*DuLinkList;//操作结果：构造一个空的线性表L。StatusInitList_DuL(DuLinkListL){if(L!=NULL){printf("线性表已存在！！！");returnINFEASIBLE;//返回-1}L=(DuLinkList)malloc(sizeof(DuLNode));if(!L){//存储分配失败printf("初始化失败！！！");exit(OVERFLOW);//exit(-2)程序异常退出}L-next=L;//先建立一个带头结点的双向链表，L-prior=L;//并使头结点2个指针域指向本身（即头指针L）returnOK;}//InitList_DuL//操作结果：销毁线性表L。StatusDestroyList_DuL(DuLinkListL){if(!L){printf("线性表未初始化。");returnINFEASIBLE;}DuLinkListp=L-next,ptmp;//p指向线性表第一个结点(线性表为空表时，指向头结点)while(p!=L){//p指向头结点时，循环停止ptmp=p-next;free(p);//释放每个数据结点的指针域p=ptmp;}free(L);//释放头结点L=NULL;returnOK;}//DestroyList_DuL//操作结果：将L重置为空表。StatusClearList_DuL(DuLinkListL){if(!L){printf("线性表未初始化。");returnINFEASIBLE;}if(L-next==L){printf("线性表本已空！！！");returnINFEASIBLE;}DuLinkListp=L-next,ptmp;//p指向线性表第一个结点while(p!=L){//p指向头结点时，循环停止ptmp=p-next;free(p);//释放每个结点的指针域p=ptmp;}L-next=L;//头结点指针域指向本身returnOK;}//ClearList_DuL//操作结果：若L为空表，返回TRUE，否则返回FALSEStatusListEmpty_DuL(DuLinkListL){if(!L){printf("线性表未初始化。");returnINFEASIBLE;//返回-1}elseif(L-next==L){printf("线性表为空。");returnTRUE;//返回1}else{printf("线性表非空。");returnFALSE;//返回0}}//ListEmpty_DuL//操作结果：返回L中数据元素个数。intListLength_DuL(DuLinkListL){if(!L){printf("线性表未初始化。");returnINFEASIBLE;//返回-1}intnElem=0;DuLinkListp=L-next;//p指向第一个结点(空表时，指向头结点)while(p!=L){nElem++;p=p-next;}returnnElem;}//ListLength//操作结果：用e返回L中第i个数据元素的值。1≤i≤ListLength(L)。StatusGetElem_DuL(DuLinkListL,inti,ElemTypee){if(!L){printf("线性表未初始化。");returnINFEASIBLE;//返回-1}DuLinkListp=L-next;//p指向第一个结点(空表时，指向头结点)intj=1;//j为计数器，统计当p指向第i个数据时，表中已有元素个数while((p-next!=L)ji)//顺指针向后查找，直到p指向第i个元素或p指向头结点{p=p-next;++j;}if(p==L||ji||i1)//p==L指向头结点，说明表为空表。jii的值大于表中现有元素个数。i1传入参数有问题。{returnERROR;//第i个元素不存在}e=p-data;//取第i个元素returnOK;}//GetElem_DuL算法2.8更改//操作结果：用p返回L中第i个数据元素的指针。1≤i≤ListLength(L)。DuLinkListGetElemP_DuL(DuLinkListL,inti){DuLinkListp=L;//p指向头结点intj=0;//j为计数器，统计当p指向第i个结点时，表中已有元素个数//p-next==L，表为空。ij，超出查找范围while((p-next!=L)ji)//顺指针向后查找，直到p指向第i个元素或p指向头结点{p=p-next;++j;}if(i1||ij+1)//ij+1i的值大于表长+1。i1传入参数有问题。{returnNULL;//i大于表长加1时，p=NULL}//插入时：i=表长加1，返回头结点;if(i==j+1){returnL;}returnp;//i表长加1时，p指向第i个结点;}//GetElem_DuL更改//操作结果：返回L中第1个与e满足compare()(数据元素判定函数)的数据元素的位序，若这样的数据元素不存在，则返回值为0。Statuscompare(ElemTypelistElem,ElemTypee){returnlistElem==e?TRUE:FALSE;}//CompareintLocateElem_DuL(DuLinkListL,ElemTypee,Status(*pfn_compare)(ElemType,ElemType)){if(!L){printf("线性表未初始化。");returnINFEASIBLE;//返回-1}intpos=1;DuLinkListp=L-next;//p指向第一个结点(空表时，指向头结点)while((p!=L)!(*pfn_compare)(p-data,e)){++pos;p=p-next;//指针后移p-next=L时，循环回到头结点}//p==L指向头结点，说明表为空表。posListLength_DuL(L)pos的值大于表中现有元素个数。if((p==L)||posListLength_DuL(L)){returnERROR;//返回0}returnpos;}//LocateElem_DuL//操作结果：若cur_e是L的数据元素，则用pre_e返回它的前驱，否则操作失败，pre_e无定义。StatusPriorElem_DuL(DuLinkListL,ElemTypecur_e,ElemTypepre_e){inti=LocateElem_DuL(L,cur_e,compare);//cur_e为第一个元素，其前驱为最后一个元素if(i==0||i==1){GetElem_DuL(L,ListLength_DuL(L),pre_e);returnOK;}GetElem_DuL(L,i-1,pre_e);returnOK;}//PriorElem_DuL//操作结果：若cur_e是L的数据元素，则用next_e返回它的后继，否则操作失败，pre_e无定义。StatusNextElem_Sq(DuLinkListL,ElemTypecur_e,ElemTypenext_e){inti=LocateElem_DuL(L,cur_e,compare);//cur_e为最后一个元素，其后继为第一个元素if(i==0||i==ListLength_DuL(L)){GetElem_DuL(L,1,next_e);returnOK;}GetElem_DuL(L,i+1,next_e);returnOK;}//NextElem_Sq//操作结果：在L中第pos个位置插入新的元素e，L的长度加1。1≤pos≤ListLength(L)+1。StatusListInsert_DuL(DuLinkListL,intpos,ElemTypee){if(!L){//线性表是否存在printf("线性表未初始化。");returnINFEASIBLE;}DuLinkListp,s;if(!(p=GetElemP_DuL(L,pos))){//在L中确定插入位置指针pprintf("插入位置不合法。");returnERROR;//i等于表长加1时，p指向头结点;i大于表长加1时，p=NULL}if(!(s=(DuLinkList)malloc(sizeof(DuLNode)))){//生成新结点printf("存储分配失败。");returnERROR;}s-data=e;//将插入的元素值赋给新生成结点的数据域s-prior=p-prior;//插入结点反向指向前驱p-prior-next=s;//前驱指向插入结点s-next=p;//插入结点指向后继p-prior=s;//后继反向指向插入结点printf("插入的位置：%d,插入的元素：%d",pos,e);returnOK;}//ListInsert_DuL算法2.18更改//操作结果：删除L的第pos个数据元素，并用e返回其值,L的长度减1。1≤pos≤ListLength(L)。StatusListDelete_DuL(DuLinkListL,intpos,ElemTypee){if(!L){//线性表是否存在printf("线性表未初始化。");returnINFEASIBLE;}DuLinkListp;if(!(p=GetElemP_DuL(L,pos))||p==L){//在L中确定第i个元素的位置指针preturnERROR;//p=NULL或p=L时，即第pos个元素不存在}e=p-data;//要删除结点的数据域，赋给ep-prior-next=p-next;//删除结点前驱指向删除结点后继p-next-prior=p-prior;//删除结点后继指向删除结点前驱free(p);//释放指针变量preturnOK;}//ListDelete_DuL算法2.19更改//操作结果：依次对L的每个数据元素调用函数visit()。一旦vistit()失败，刚操作失败。Statusvisit(ElemTypee){printf("%d-",e);returnOK;}StatusListTraverse_DuL(DuLinkListL,Status(*pfn_visit)(ElemType)){if(!L){printf("线性表未初始化。");returnINFEASIBLE;}if(L-next==L){printf("线性表为空表。");returnERROR;}DuLinkListp=L-next;//p指向第一个结点while(p!=L){visit(p-data);p=p-next;}returnOK;}//ListTraverse//创建随机表,包含10个随机数（头插法）。voidCreateList_DuL_10(DuLinkListL){//提供随机数种子srand((unsigned)time(NULL));//生成头结点L=(DuLinkList)malloc(sizeof(DuLNode));if(!L){printf("存储分配失败！！！");exit(OVERFLOW);//exit(-1)程序异常退出}L-next=L;//头结点指针域指向本身L-prior=L;for(inti=0;i10;i++){//生成新结点DuLinkListp=(DuLinkList)malloc(sizeof(DuLNode));//scanf("%d",p-data);//输入元素值赋给新生成结点的数据域p-data=rand()%100;//插入到表头p-next=L-next;//插入结点指向后继p-prior=L;//插入结点反向指向头结点L-prior-next=p;//后继反向指向插入结点L-next=p;//头结点指向插入结点//printf("%d",p-data);//查看是否插入了新的元素}}//CreateList_DuL_10//逆位序输入(随机产生)n个元素的值，建立带表头结点的线性表L（头插法）。voidCreateList_DuL_Head(DuLinkListL,intn){srand((unsigned)time(NULL));//初始化随机数种子//先建立一个带头结点的单链表L=(DuLinkList)malloc(sizeof(DuLNode));if(!L){printf("存储分配失败！！！");exit(OVERFLOW);//exit(-1)程序异常退出}L-next=L;//头结点指针域指向本身L-prior=L;L-data=5201314;for(inti=n;i0;--i){DuLinkListp=(DuLinkList)malloc(sizeof(DuLNode));//生成新结点//scanf("%d",p-data);//输入元素值//随机生成100以内的数字p-data=rand()%100;//将生成的元素值赋给新生成结点的数据域//p-data=i;//将生成的元素值赋给新生成结点的数据域//插入到表头p-next=L-next;//插入结点指向第一个结点L-next-prior=p;//第一个结点反向指向插入结点p-prior=L;//插入结点反向指向头结点L-next=p;//头结点指向插入结点}}//CreateList_DuL算法2.11更改//顺位序输入(随机产生)n个元素的值，建立带表头结点的线性表L（尾插法）。voidCreateList_DuL_Tail(DuLinkListL,intn){srand((unsigned)time(NULL));//初始化随机数种子//先建立一个带头结点的单链表L=(DuLinkList)malloc(sizeof(DuLNode));if(!L){printf("存储分配失败！！！");exit(OVERFLOW);//exit(-1)程序异常退出}L-next=L;//头结点指针域指向本身L-prior=L;for(inti=0;in;++i){DuLinkListp=(DuLinkList)malloc(sizeof(DuLNode));//scanf("%d",p-data);//输入元素值//随机生成100以内的数字p-data=rand()%100;//将生成的元素值赋给新生成结点的数据域//插入到表尾p-prior=L-prior;//插入结点反向指向表尾结点L-prior-next=p;//表尾结点指向插入结点p-next=L;//插入结点指向头结点L-prior=p;//头结点反向指向插入结点}}//初始化菜单voidinitMenu(){printf("\n\t\t*****************************************\n");printf("\n\t\t\t\t循环双向链表\n");printf("\n\t\t1.创建随机表\t\t2.构造空线性表\n\t\t3.销毁线性表\t\t4.清空线性表\n\t\t5.线性表是否为空\t6.线性表的长度");printf("\n\t\t7.查找表中元素\t8.插入新元素\n\t\t9.删除某个元素\t10.遍历线性表\n\t\t11.回到主菜单\t\t0.退出");}//回到主菜单voidmainMenu(){printf("\n\t\t*****************************************\n");printf("\n\t\t\t\t循环双向链表\n");printf("\n\t\t1.创建随机表\t\t2.构造空线性表\n\t\t3.销毁线性表\t\t4.清空线性表\n\t\t5.线性表是否为空\t6.线性表的长度");printf("\n\t\t7.查找表中元素\t8.插入新元素\n\t\t9.删除某个元素\t10.遍历线性表\n\t\t11.回到主菜单\t\t0.退出");}intmain(){DuLinkListL=NULL;initMenu();intselect=-1;while(select!=0){printf("\n\n请选择你的操作：");scanf("%d",select);switch(select){case1://创建随机表{intnCreateOption=-1;while(nCreateOption!=0nCreateOption!=11){printf("\n1.头插法2.尾插法3.10个元素的随机表11.回到主菜单0.退出查找\n请选择你的操作：");scanf("%d",nCreateOption);switch(nCreateOption){case1://1.头插法{printf("请输入要创建的随机表元素个数：");intnElem;scanf("%d",nElem);CreateList_DuL_Head(L,nElem);printf("头插法创建随机链表：");ListTraverse_DuL(L,visit);}break;case2://2.尾插法{printf("请输入要创建的随机表元素个数：");intnElem;scanf("%d",nElem);CreateList_DuL_Tail(L,nElem);printf("尾插法创建随机链表：");ListTraverse_DuL(L,visit);}break;case3://3.10个元素的随机表CreateList_DuL_10(L);printf("10个元素的随机表：");ListTraverse_DuL(L,visit);break;case11://11.回到主菜单mainMenu();break;case0://0.退出查找break;default:printf("请输入正确的数字!!!\n");break;}}}break;case2://构造空线性表printf("构造一个空的线性表L。");InitList_DuL(L);break;case3://销毁线性表printf("销毁线性表L。");DestroyList_DuL(L);break;case4://清空线性表printf("将L重置为空表。");ClearList_DuL(L);break;case5://线性表是否为空ListEmpty_DuL(L);break;case6://线性表的长度{intlLength=ListLength_DuL(L);if(lLength!=-1)printf("线性表的长度为:%d",lLength);}break;case7://查找表中元素{intnSearchOption=-1;while(nSearchOption!=0nSearchOption!=11){printf("1.按位置查找\t2.按元素查找\t11.回到主菜单\t0.退出查找\n请选择你的操作：");scanf("%d",nSearchOption);switch(nSearchOption){case1://1.按位置查找{intpos;ElemTypee;printf("请输入要查找的位置：");scanf("%d",pos);intret=GetElem_DuL(L,pos,e);if(ret==-1){printf("\n");break;}elseif(ret==0){printf("查找位置不正确！\n");break;}printf("第%d个元素的值为：%d",pos,e);ElemTypepre_e,next_e;if(PriorElem_DuL(L,e,pre_e))printf("前一个元素为：%d",pre_e);if(NextElem_Sq(L,e,next_e))printf("后一个元素为：%d",next_e);printf("\n");}break;//2.按元素查找case2:{printf("请输入要查找的元素：");ElemTypee;scanf("%d",e);intpos=LocateElem_DuL(L,e,compare);if(pos==-1){printf("\n");break;}elseif(pos==0){printf("没有值为%d的元素。\n",e);break;}printf("值为%d是表中的第%d个元素。\n",e,pos);}break;case11://11.回到主菜单mainMenu();break;case0://0.退出查找break;default:printf("请输入正确的数字!!!\n");break;}}}break;case8://插入新元素{ElemTypee;intpos;intnInsertOption=-1;while(nInsertOption){printf("请输入要插入的元素位置和元素的值：");scanf("%d%d",pos,e);intret=ListInsert_DuL(L,pos,e);//线性表未初始化，中断循环，回到主界面if(ret==-1)break;//插入位置不合法，结束本次循环，继续下次循环elseif(!ret){printf("\n");continue;}//插入元素printf("\n现在线性表为：");ListTraverse_DuL(L,visit);printf("\n1.是0.否是否继续:");scanf("%d",nInsertOption);}}break;case9://删除某个元素{intnDeleteOption=-1;while(nDeleteOption!=0nDeleteOption!=11){printf("1.按位置删除\t2.按元素删除\t11.回到主菜单\t0.退出删除\n请选择你的操作：");scanf("%d",nDeleteOption);switch(nDeleteOption){case1://1.按位置删除{ElemTypee;intpos;printf("请输入要删除的位置：");scanf("%d",pos);intret=ListDelete_DuL(L,pos,e);if(ret==-1){printf("\n");break;}elseif(ret==0){printf("删除位置不正确！\n");break;}printf("现在线性表为：");ListTraverse_DuL(L,visit);printf("\n");}break;case2://2.按元素删除{printf("请输入要删除的元素：");ElemTypee;scanf("%d",e);//删除的将是第一个出现的元素intpos=LocateElem_DuL(L,e,compare);if(pos==-1){printf("\n");break;}elseif(pos==0){printf("没有值为%d的元素。",e);break;}printf("值为%d是表中的第%d个元素。",e,pos);ListDelete_DuL(L,pos,e);printf("\n现在线性表为：");ListTraverse_DuL(L,visit);printf("\n");}break;case11://11.回到主菜单mainMenu();break;case0://0.退出查找break;default:printf("请输入正确的数字!!!\n");break;}}}break;case10://遍历线性表printf("遍历线性表：");ListTraverse_DuL(L,visit);break;case11://回到主菜单mainMenu();break;case0://退出break;default:printf("请输入正确的数字!!!");break;}}return0;}

参考资料

1.数据结构：使用C语言第4版2.