单循环链表基本操作

合集下载

单链表的基本操作实验报告

单链表的基本操作实验报告

湖南第一师范学院信息科学与工程系实验报告课程名称:数据结构与算法成绩评定:实验项目名称:单链表的基本操作指导教师:学生姓名:沈丽桃学号: 10403080118 专业班级: 10教育技术实验项目类型:验证实验地点:科B305 实验时间: 2011 年 10 月20 日一、实验目的与要求:实验目的:实现线性链表的创建、查找、插入、删除与输出。

基本原理:单链表的基本操作二、实验环境:(硬件环境、软件环境)1.硬件环境:奔ⅣPC。

2.软件环境:Windows XP 操作系统,TC2.0或VC++。

三、实验内容:(原理、操作步骤、程序代码等)#include<stdio.h>#include<stdlib.h>#include<malloc.h>struct celltype{int element;struct celltype*next;};typedef int position;void main(){struct celltype*head,*p;int x,choice;void INSERT(int x,struct celltype*p);void LOCATE(int x,struct celltype*p);void DELETE(int x,struct celltype*p);p=(struct celltype*)malloc(sizeof(struct celltype));head=p;p->element=0;p->next=NULL;printf(“Please option:1:Insert 2:Locate 3:Delete\n”);printf(“Please choose:”);scanf(“%d”,&choice);switch(choice)case 1:printf(“Please input a node:”);scanf(“%d”,&x);p=head;INSERT(x,p);for(p=head;p!=NULL;p=p->next)printf(“%d”,p->element);printf(“\n”);break;case 2:printf(“Please input the data you want to locate:”); scanf(“%d”,&x);p=head;LOCATE(x,p);break;case 3:printf(“Please input the data you want to delete:”); scanf(“%d”,&x);DELETE(x,p);for(p=head;p!=NULL;p=p->next)printf(“%d”,p->next);printf(“\n”);break;}void INSERT(int x,struct celltype*p){struct celltype*t,*q;q=(struct celltype*)malloc(sizeof(struct celltype)); q->next=x;while((x>p->element)&&(p!=NULL)){t=p;p=p->next;}if((x>p->element)&&(p->next!=NULL)){p->next=q;q->next=NULL;}else{q->next=p;t->next=q;}}void LOCATE(int x,struct celltype*p){while(p->next!=NULL)if(p->next->element==x)printf(“the number %d is in %d\n”,x,p);else printf(“the number not exist!\n”);}void DELETE(int x,struct celltype*p){while((p->element!=x)&&(p->next!=NULL)){t=p;p=p->next;}if(p->element==x)t->next=p->next}error C2018:unknown character ’Oxal’error C2065:’Please’:undeclared identifiererror C4024:’printf’:different types for formal and actual parameter 1error C4047:’function’:’const*differs in levers of indirection from ’int’error C2146:syntaxerror:missing’)’before identifier’option’error C2017:illegal escape sequenceerror C2059:syntax error:’)’error C2143:syntax error:missing’)’before’%’出现了很多错误,主要是因为printf里的一对双引号不是英文状态下的。

单链表的基本操作

单链表的基本操作

10)调用头插法的函数,分别输入10,20,分别回车:
11)调用尾插法的函数,分别输入30,40
12)查找单链表的第四个元素:
13)主函数中传入参数,删除单链表的第一个结点:
14)主函数传入参数,删除第0个未位置的元素,程序报错:
15)最后,输出单链表中的元素:
return 0;
}
6)编译,连接,运行源代码:
7)输入8,回车,并输入8个数,用空格分隔开,根据输出信息,可以看出,链表已经拆分为两个
五、实验总结
1.单链表采用的是数据+指针的表示形式,指针域总是指向下一个结
点(结构体)的地址,因此,在内存中的地址空间可以是不连续的,操作比顺序存储更加的方便
2.单链表使用时,需要用malloc函数申请地址空间,最后,删除元
素时,使用free函数释放空间。

PTA7-4单链表基本操作

PTA7-4单链表基本操作

PTA7-4单链表基本操作7-4 单链表基本操作请编写程序实现单链表插⼊、删除结点等基本算法。

给定⼀个单链表和⼀系列插⼊、删除结点的操作序列,输出实施上述操作后的链表。

单链表数据域值为整数。

输⼊格式:输⼊第1⾏为1个正整数n,表⽰当前单链表长度;第2⾏为n个空格间隔的整数,为该链表n个元素的数据域值。

第3⾏为1个正整数m,表⽰对该链表施加的操作数量;接下来m⾏,每⾏表⽰⼀个操作,为2个或3个整数,格式为0 k d或1 k。

0 k d表⽰在链表第k个结点后插⼊⼀个数据域值为d的结点,若k=0则表⽰表头插⼊。

1 k表⽰删除链表中第k个结点,此时k不能为0。

注:操作序列中若含有不合法的操作(如在长度为5的链表中删除第8个结点、删除第0个结点等),则忽略该操作。

n和m不超过100000。

输出格式:输出为⼀⾏整数,表⽰实施上述m个操作后的链表,每个整数后⼀个空格。

输⼊数据保证结果链表不空。

输⼊样例:51 2 3 4 550 2 80 9 60 0 71 01 6输出样例:7 1 2 8 3 5参照课本的实现#include<iostream>#include<iomanip>#include<stdlib.h>using namespace std;typedef int ElemType;typedef int Status;#define ERROR 0#define OK 1#define OVERFLOW 3typedef struct LNode{ElemType data;struct LNode *next;}LNode ,*LinkList;Status ListInsert(LinkList L,int i,ElemType e){int j=0;LinkList p=L,s;while(p&&j<i-1) // 寻找第i-1个结点{p=p->next;j++;}if(!p||j>i-1) // i⼩于1或者⼤于表长return ERROR;s=(LinkList)malloc(sizeof(LNode)); // ⽣成新结点s->data=e; // 插⼊L中s->next=p->next;p->next=s;return OK;}Status ListDelete(LinkList L,int i){int j=0;LinkList p=L,q;while(p->next&&j<i-1) // 寻找第i个结点,并令p指向其前趋{p=p->next;j++;}if(!p->next||j>i-1) // 删除位置不合理return ERROR;q=p->next; // 删除并释放结点p->next=q->next;free(q);return OK;}int main(){ios::sync_with_stdio(false);cin.tie(0);cout.tie(0);LinkList L;L=(LinkList)malloc(sizeof(LNode)); // 产⽣头结点,并使L指向此头结点 if(!L) // 存储分配失败exit(OVERFLOW);L->next=NULL;int n=0,m=0;LinkList db=L,da;cin>>n;for(int i=0;i<n;i++){da=(LinkList)malloc(sizeof(LNode));cin>>da->data;da->next=NULL;db->next=da;db = da;}cin>>m;for(int i=0;i<m;i++){int o,x,y;cin>>o;if(o==0){cin>>x>>y;ListInsert(L,x+1,y);}else if(o==1){cin>>x;ListDelete(L,x);}else{exit(ERROR);}}LinkList p=L->next;while(p!=NULL){cout<<p->data<<" ";p = p->next;}return 0;}。

循环单链表

循环单链表

循环单链表循环单链表是一种特殊的单链表,它的最后一个节点的指针指向第一个节点,形成一个环。

它具有单链表独有的优点,同时又克服了单链表存在的缺点。

因此,循环单链表在实际应用中受到了极大的欢迎。

本文介绍了循环单链表的概念,结构特性和实现功能,并分析了其与普通单链表的区别。

1.环单链表的概念循环单链表,也叫循环链表,是一种特殊的单链表,它的最后一个节点的指针指向第一个节点,形成一个环。

循环链表的结构比普通的单链表略有不同,其头结点的next域指向头节点,该结构最显著的特点就是头节点的“上一个”节点和最后一个节点“下一个”节点都是头结点,所以可以利用循环链表来实现双向链表的操作。

2.环单链表的结构特性循环单链表是一种特殊的单链表,其最后一个节点指针指向头结点,从结构上来看,它具有单链表的特点,如指针存储结构、节点为一个结构体成员以及只有单向指针,但又与普通单链表不同,它的结构特征有:(1)头结点的next域指向自身;(2)最后一个节点的next域也指向头结点;(3)整个结构类似一个拥有多叉指针的环形结构体。

3.环单链表的实现功能循环单链表的实现功能包括插入、删除、查找等,这些基本操作的实现和普通单链表的实现方法基本相同,只是有一些细节的不同。

例如,在普通单链表的删除操作中,如果需要删除的节点是链表的最后一个节点,则需要修改链表的尾指针,但是在循环单链表中,只需要修改头结点的next域指向,就可以实现操作。

4.与普通单链表的区别循环单链表有一些独特的结构特点,同时又克服了普通单链表的缺点,因此在实际应用中受到了极大的欢迎。

(1)普通单链表无法实现双向遍历,而循环单链表可以实现双向遍历和遍历,因为它有头结点和最后一个节点,所以可以实现双向遍历,再加上其结构特点,可以实现对双向链表的操作。

(2)普通单链表遍历需要维护一个辅助指针,而循环单链表则不需要,只需要从头结点开始,依次访问每一个节点,直到头结点。

结论:循环单链表是一种特殊的单链表,它的结构特征是头结点的next域指向头结点,最后一个节点的next域也指向头结点,它克服了普通单链表的缺点,可以实现双向遍历,同时又不需要维护辅助指针,因此广泛应用在实际工程中。

算法与数据结构实验报告

算法与数据结构实验报告

2015-2016学年第二学期《算法与数据结构》课程实验报告专业软件工程学生姓名成晓伟班级软件141学号1410075094实验学时16实验教师徐秀芳信息工程学院实验一单链表的基本操作一、实验目的1.熟悉C语言上机环境,进一步掌握C语言的基本结构及特点。

2.掌握线性表的各种物理存储表示和C语言实现。

3.掌握单链表的各种主要操作的C语言实现。

4.通过实验理解线性表中的单链表存储表示与实现。

二、主要仪器及耗材普通计算机三、实验内容与要求1、用C语言编写一个单链表基本操作测试程序。

(1)初始化单链表(2)创建单链表(3)求单链表长度(4)输出单链表中每一个结点元素(5)指定位置插入某个元素(6)查找第i个结点元素的值(7)查找值为e 的结点,并返回该结点指针(8)删除第i个结点(9)销毁单链表2、实验要求(1)程序中用户可以选择上述基本操作。

程序启动后,在屏幕上可以菜单形式显示不同功能,当按下不同数字后完成指定的功能,按其他键,则显示错误后重新选择。

(2)要求用线性表的顺序存储结构,带头结点的单链表存储结构分别实现。

(3)主函数实现对基本操作功能的调用。

3、主要代码(1)初始化单链表LinkList *InitList(){ //创建一个空链表,初始化线性表LinkList *L;L=(LinkList *)malloc(sizeof(LinkList));L->next=NULL;return L;}(2)创建单链表//头插法void CreateListF(LinkList *L){LinkList *s;int i=1,a=0;while(1){printf("输入第%d个元素(0表示终止)",i++);scanf("%d",&a);if(a==0)break;s=(LinkList *)malloc(sizeof(LinkList));s->data=a;s->next=L->next;L->next=s;}}(3)求链表长度int ListLength(LinkList *L){ //求链表长度int n=0;LinkList *p=L;while(p->next!=NULL){p=p->next;n++;}return(n);}(4)在指定位置插入元素int InsertList(LinkList *L,int i,ElemType e){LinkList *p=L,*s;int j=0;while(p!=NULL&&j<i-1){p=p->next;j++;} //找出要插入的位置的前一个位置if(p==NULL){return 0;}else{s=(LinkList *)malloc(sizeof(LinkList));s->data=e;s->next=p->next;p->next=s;return 1;}}(5)输出链表void DispList(LinkList *L){ //输出链表LinkList *p=L->next;while(p!=NULL){printf("%d",p->data);p=p->next;}printf("\n");}(6)查找链表中指定元素int GetElem(LinkList *L,int i){ //查找链表中指定元素LinkList *p=L;int j=0;while(j<i&&p!=NULL){j++;p=p->next;}if(p==NULL){return 0;}else{return p->data;}}(7)查找值是e的结点并返回该指针LinkList *LocateElem(LinkList *L,ElemType e){ //查找值是e的结点并返回该指针int i=1;LinkList *p=L;while(p!=NULL)if(p->data==e) return p;}if(p==NULL){return NULL;}}(8)删除元素int ListDelete(LinkList *L,int i,ElemType *e){ //删除元素LinkList *p=L,*q;int j=0;while(p!=NULL&&j<i-1){p=p->next;j++;} //找到要删除元素地址的前一个地址if(p==NULL){ return 0;} //不能删除else{q=p->next;*e=q->data;p->next=q->next;free(q); //删除成功return 1;}}(9)销毁链表void DestroyList(LinkList *L){//销毁链表LinkList *pre=L,*p=L->next;while(p!=NULL){free(pre);pre=p;p=pre->next;}free(pre);}main函数:int main(){LinkList *L;ElemType e;int i;L=InitList();CreateListF(L);DispList(L);printf("输入要查找的元素位置:\n");scanf("%d",&i);e=GetElem(L,i);printf("%d\n",e);printf("单链表长度为:%d\n",ListLength(L));printf("输入要删除元素的位置:");scanf("%d",&i);if (i>ListLength(L)){printf("超出范围重新输入");scanf("%d",&i);}if(ListDelete(L,i,&e)==0){printf("未找到元素\n");}else DispList(L);printf("输入插入元素的位置和值:");scanf("%d%d",&i,&e);InsertList(L,i,e);DispList(L);return 0;}4、测试数据及测试结果输入:23 56 12 28 45输出:四、注意事项1、存储结构定义和基本操作尽可能用头文件实现。

单链表基本操作的实现

单链表基本操作的实现

单链表基本操作的实现单链表是一种常见的数据结构,它由多个节点组合而成,每个节点包含一个数据元素和一个指向下一个节点的指针。

通过指针,我们可以方便地在单链表中进行插入、删除和遍历等操作。

以下是关于单链表基本操作的实现。

1. 单链表的创建单链表的创建需要定义一个空的头结点,它的作用是方便在链表的头部进行添加和删除节点操作。

一个空的头节点可以在链表初始化的过程中进行创建。

```typedef struct Node{int data;struct Node *next;}Node;Node *createList(){Node *head = (Node*)malloc(sizeof(Node)); //创建空的头节点head->next = NULL;return head; //返回头节点的地址}```2. 单链表的插入单链表的插入可以分为在链表头部插入、在链表尾部插入和在链表中间插入三种情况。

a. 在链表头部插入节点:```void insertAtHead(Node *head, int data){Node *node = (Node*)malloc(sizeof(Node));node->data = data;node->next = head->next;head->next = node;}```b. 在链表尾部插入节点:```void insertAtTail(Node *head, int data){Node *node = (Node*)malloc(sizeof(Node));node->data = data;node->next = NULL;Node *p = head;while(p->next != NULL){p = p->next;}p->next = node;}```c. 在链表中间插入节点:```void insertAtMid(Node *head, int data, int pos){ Node *node = (Node*)malloc(sizeof(Node)); node->data = data;node->next = NULL;Node *p = head;int count = 0;while(p->next != NULL && count < pos-1){ p = p->next;count++;}if(count == pos-1){node->next = p->next;p->next = node;}else{printf("插入位置错误!");}}```3. 单链表的删除单链表的删除可以分为在链表头部删除、在链表尾部删除和在链表中间删除三种情况。

单链表的基本操作实验问题与对策

单链表的基本操作实验问题与对策

单链表的基本操作实验问题与对策单链表是一种非常基础且常见的数据结构,被广泛应用于计算机科学和相关领域中。

它通过使用一系列节点来存储元素,每个节点都包含一个值和一个指向下一个节点的指针。

这些节点以线性方式连接,形成了一个单向链表。

在进行单链表的基本操作实验时,可能会遇到一些常见的问题和挑战。

例如,在进行插入操作时,可能会出现指针错误或内存分配失败的问题。

在删除操作中,可能会遇到无法找到指定元素或无法正确更新节点指针的问题。

在进行查找操作时,可能会遇到查找效率低下或无法找到特定元素的问题。

而在遍历操作中,可能会遇到指针断裂或无限循环的问题。

为了解决这些问题,我们可以采取一些对策。

例如,在进行插入操作时,我们可以使用更高效的数据结构或算法来避免指针错误和内存分配失败的问题。

在删除操作中,我们可以使用更精确的查找算法来找到指定元素并正确更新节点指针。

在进行查找操作时,我们可以使用更优化的查找算法或数据结构来提高查找效率并找到特定元素。

而在遍历操作中,我们可以使用更安全的遍历算法来避免指针断裂和无限循环的问题。

总之,单链表是一种非常有用的数据结构,在进行基本操作实验时可能会遇到一些问题和挑战。

但只要我们采取适当的对策,就可以有效地解决这些问题并更好地应用单链表这种数据结构。

问题1:插入节点时如何确保正确的位置?对策:在插入节点之前,需要遍历链表以找到正确的位置。

可以使用循环来遍历链表,确保插入的位置是正确的。

另外,可以考虑维护一个指向前一个节点的指针,以便在插入时更容易操作。

问题2:如何删除节点?对策:删除节点时,需要找到待删除节点的前一个节点,并将其指针指向待删除节点的下一个节点,然后释放待删除节点的内存。

确保在删除节点之前释放内存,以避免内存泄漏。

问题3:如何遍历链表?对策:遍历链表通常需要使用循环,从链表的头节点开始,沿着指针依次访问每个节点,直到达到链表的末尾。

可以使用循环结构来实现遍历,或者使用递归方法。

单链表基本操作

单链表基本操作

单链表基本操作在计算机科学里,链表是一种常见的数据结构,它可以用来解决各种复杂的问题。

其中,单链表是最常见的一种,它由一系列节点组成,每个节点包含了一个数据元素和一个指针,指向下一个节点。

这篇文章将介绍单链表的基本操作,包括创建、插入、删除和遍历等。

创建单链表创建单链表是基本操作之一,它有两种方法:头插法和尾插法。

头插法是从链表的头节点开始,逐个将新节点插入。

具体来说,创建一个空链表,设置一个头节点,将头节点的指针指向空;依次输入新节点,将新节点的指针指向表头,将表头的指针指向新节点。

这样,每插入一个新节点就成为了新的表头,即最后插入的节点为新的表头。

尾插法则是从链表的尾节点开始,逐个将新节点插入。

具体来说,创建一个空链表,设置一个头节点,将头节点的指针指向空;依次输入新节点,将新节点的指针指向空,将最后一个节点的指针指向新节点。

这样,最后插入的节点为尾节点,它的指针值为空。

插入节点插入节点是指在单链表的任意位置插入一个新节点。

插入节点的前提是找到插入位置,可以通过遍历单链表来查找插入位置。

插入新节点的基本步骤如下:1、创建新节点;2、将新节点的指针指向待插入节点的后继节点;3、将待插入节点的指针指向新节点。

删除节点删除节点是指删除单链表中的任意节点。

删除节点的前提是找到删除的节点位置,可以通过遍历单链表来查找删除位置。

删除节点的基本步骤如下:1、找到要删除的节点;2、将该节点的前驱节点的指针指向该节点的后继节点;3、删除该节点。

遍历节点遍历节点是指按照链表的顺序依次访问链表中的各个节点。

遍历节点的基本步骤如下:1、从链表的头节点开始遍历;2、依次访问每个节点的数据元素;3、通过指针访问下一个节点,直到遇到尾节点。

优缺点单链表的优点是简单,灵活,易于实现和扩展,可以方便地进行插入和删除等操作。

其缺点是存在指针开销,查找元素时需要遍历整个链表,不能直接访问链表中任意位置的节点。

总结单链表是一种最常用的数据结构,它是由一系列节点组成,每个节点包含一个数据元素和一个指针,指向下一个节点。

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。

单循环链表基本操作/* (程序名) */#include<stdlib.h>#include<stdio.h>#include<stdlib.h>#include<string.h>#include<ctype.h>#include<malloc.h> /* malloc()等*/#include<limits.h> /* INT_MAX等*/#include<stdio.h> /* EOF(=^Z或F6),NULL */#include<stdlib.h> /* atoi() */#include<io.h> /* eof() */#include<math.h> /* floor(),ceil(),abs() */#include<process.h> /* exit() *//* 函数结果状态代码*/#define TRUE 1#define FALSE 0#define OK 1#define ERROR 0#define INFEASIBLE -1/* #define OVERFLOW -2 因为在math.h中已定义OVERFLOW的值为3,故去掉此行*/ typedef int Status; /* Status是函数的类型,其值是函数结果状态代码,如OK等*/typedef int Boolean; /* Boolean是布尔类型,其值是TRUE或FALSE */typedef int ElemType;/* c2-2.h 线性表的单链表存储结构*/struct LNode{ElemType data;struct LNode *next;};typedef struct LNode *LinkList; /* 另一种定义LinkList的方法*///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// 单循环链表基本操作/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////* bo2-4.c 设立尾指针的单循环链表(存储结构由c2-2.h定义)的12个基本操作*/Status InitList_CL(LinkList *L){ /* 操作结果:构造一个空的线性表L */*L=(LinkList)malloc(sizeof(struct LNode)); /* 产生头结点,并使L指向此头结点*/if(!*L) /* 存储分配失败*/exit(OVERFLOW);(*L)->next=*L; /* 指针域指向头结点*/return OK;}Status DestroyList_CL(LinkList *L){ /* 操作结果:销毁线性表L */LinkList q,p=(*L)->next; /* p指向头结点*/while(p!=*L) /* 没到表尾*/{q=p->next;free(p);p=q;}free(*L);*L=NULL;return OK;}Status ClearList_CL(LinkList *L) /* 改变L */{ /* 初始条件:线性表L已存在。

操作结果:将L重置为空表*/LinkList p,q;// *L=(*L)->next; /* L指向头结点*/p=(*L)->next; /* p指向第一个结点*/while(p!=*L) /* 没到表尾*/{q=p->next;free(p);p=q;}(*L)->next=*L; /* 头结点指针域指向自身*/return OK;}Status ListEmpty_CL(LinkList L){ /* 初始条件:线性表L已存在。

操作结果:若L为空表,则返回TRUE,否则返回FALSE */if(L->next==L) /* 空*/return TRUE;elsereturn FALSE;}int ListLength_CL(LinkList L){ /* 初始条件:L已存在。

操作结果:返回L中数据元素个数*/int i=0;LinkList p=L->next; /* p指向头结点*/while(p!=L) /* 没到表尾*/{i++;p=p->next;}return i;}Status GetElem_CL(LinkList L,int i,ElemType *e){ /* 当第i个元素存在时,其值赋给e并返回OK,否则返回ERROR */int j=1; /* 初始化,j为计数器*/// LinkList p=L->next->next; /* p指向第一个结点*/LinkList p=L->next; /* p指向第一个结点*/if(i<=0||i>ListLength_CL(L)) /* 第i个元素不存在*/return ERROR;while(j<i){ /* 顺指针向后查找,直到p指向第i个元素*/p=p->next;j++;}*e=p->data; /* 取第i个元素*/return OK;}int LocateElem_CL(LinkList L,ElemType e,Status(*compare)(ElemType,ElemType)){ /* 初始条件:线性表L已存在,compare()是数据元素判定函数*//* 操作结果:返回L中第1个与e满足关系compare()的数据元素的位序。

*//* 若这样的数据元素不存在,则返回值为0 */int i=0;// LinkList p=L->next->next; /* p指向第一个结点*/LinkList p=L->next; /* p指向第一个结点*/while(p!=L->next){i++;if(compare(p->data,e)) /* 满足关系*/return i;p=p->next;}return 0;}Status PriorElem_CL(LinkList L,ElemType cur_e,ElemType *pre_e){ /* 初始条件:线性表L已存在*//* 操作结果:若cur_e是L的数据元素,且不是第一个,则用pre_e返回它的前驱,*/ /* 否则操作失败,pre_e无定义*///LinkList q,p=L->next->next; /* p指向第一个结点*/LinkList q,p=L->next; /* p指向第一个结点*/q=p->next;while(q!=L->next) /* p没到表尾*/{if(q->data==cur_e){*pre_e=p->data;return TRUE;}p=q;q=q->next;}return FALSE;}Status NextElem_CL(LinkList L,ElemType cur_e,ElemType *next_e){ /* 初始条件:线性表L已存在*//* 操作结果:若cur_e是L的数据元素,且不是最后一个,则用next_e返回它的后继,*/ /* 否则操作失败,next_e无定义*/// LinkList p=L->next->next; /* p指向第一个结点*/LinkList p=L->next; /* p指向第一个结点*/while(p!=L) /* p没到表尾*/{if(p->data==cur_e){*next_e=p->next->data;return TRUE;}p=p->next;}return FALSE;}Status ListInsert_CL(LinkList *L,int i,ElemType e) /* 改变L */{ /* 在L的第i个位置之前插入元素e */LinkList p=(*L)->next,s; /* p指向头结点*/int j=0;if(i<=0||i>ListLength_CL(*L)+1) /* 无法在第i个元素之前插入*/return ERROR;while(j<i-1) /* 寻找第i-1个结点*/{p=p->next;j++;}s=(LinkList)malloc(sizeof(struct LNode)); /* 生成新结点*/s->data=e; /* 插入L中*/s->next=p->next;p->next=s;// if(p==*L) /* 改变尾结点*/// *L=s;return OK;}Status ListDelete_CL(LinkList *L,int i,ElemType *e) /* 改变L */ { /* 删除L的第i个元素,并由e返回其值*/LinkList p=(*L)->next,q; /* p指向头结点*/int j=0;if(i<=0||i>ListLength_CL(*L)) /* 第i个元素不存在*/return ERROR;while(j<i-1) /* 寻找第i-1个结点*/{p=p->next;j++;}q=p->next; /* q指向待删除结点*/p->next=q-&。

相关文档
最新文档