单链表的建立查找插入删除

单链表查找插⼊删除算法时间效率分析单链表查找时间效率分析：
代码：
Lnode *LocateElem_L(LinkList L, ElemType e){
//在线性表L中查找值为 e 的数据元素
//找到，则返回 L 中值为 e 的数据元素的地址
//查找失败返回NULL
p=L->next;
while(p!=NULL && p->data!=e){
p=p->next;
}
return p;
}
上述代码中，循环体⾥的 p=p->next 执⾏多少次？或者说循环执⾏多少次，和我们要查找的元素 e 所在位置有关系如果单链表中第⼀个元素，或者说⾸元结点就是 e ，那么仅执⾏⼀次即可。

如果不是，则顺着指针链，依次向后查找。

因线性链表只能顺序存取，即在查找时要从头指针找起，查找的时间福再度为 O(n)。

插⼊和删除：
因线性链表在插⼊或删除时，不需要移动元素，只要修改指针，⼀般情况下时间复杂度为O(1)。

但是，如果要在单链表中进⾏前插或删除操作，由于要从头查找前驱结点，所耗时间复杂度为O(n)。

进⾏插⼊和删除的操作是常数即便，但是寻找前驱才要O(n)。

计算机学院实验报告课程名称：数据结构实验名称：单链表学生姓名：***学生学号：***********实验日期：2012一、实验目的1．理解数据结构中带头结点单链表的定义和逻辑图表示方法。

2．掌握单链表中结点结构的C++描述。

3．熟练掌握单链表的插入、删除和查询算法的设计与C++实现。

二、实验内容1．编制一个演示单链表插入、删除、查找等操作的程序。

三、实验步骤1．需求分析本演示程序用C++6.0编写，完成单链表的生成，任意位置的插入、删除，以及确定某一元素在单链表中的位置。

①输入的形式和输入值的范围：插入元素时需要输入插入的位置和元素的值；删除元素时输入删除元素的位置；查找操作时需要输入元素的值。

在所有输入中，元素的值都是整数。

②输出的形式：在所有三种操作中都显示操作是否正确以及操作后单链表的内容。

其中删除操作后显示删除的元素的值，查找操作后显示要查找元素的位置。

③程序所能达到的功能：完成单链表的生成（通过插入操作）、插入、删除、查找操作。

④测试数据：A．插入操作中依次输入11，12，13，14，15，16，生成一个单链表B．查找操作中依次输入12，15，22返回这3个元素在单链表中的位置C．删除操作中依次输入2，5，删除位于2和5的元素2．概要设计1）为了实现上述程序功能，需要定义单链表的抽象数据类型：（1）insert初始化状态：单链表可以不为空集；操作结果：插入一个空的单链表L。

（2）decelt操作结果：删除已有的单链表的某些结点。

（3）display操作结果：将上述输入的元素进行排列显示。

（4）modify操作结果：将上述输入的某些元素进行修改。

（5）save操作结果：对上述所有元素进行保存。

（6）load操作结果：对上述元素进行重新装载。

3．使用说明程序执行后显示======================1.单链表的创建2.单链表的显示3.单链表的长度4.取第i个位置的元素5.修改第i个位置的元素6.插入元素到单链表里7.删除单链表里的元素8.合并两个单链表9.退出系统=======================5.源代码：#include<iostream>using namespace std;#define true 1#define false 0#define ok 1#define error 0#define overflow -2typedef int Status;typedef int ElemType;typedef struct LNode{ ElemType data;struct LNode *next;}LNode,*LinkList;void CreateList(LinkList &L,int n){ LinkList p;L=new LNode;L->next=NULL;LinkList q=L;for(int i=1;i<=n;i++){ p=new LNode;cin>>p->data;p->next=NULL;q->next=p;q=p; }}Status GetElem(LinkList L,int i,ElemType &e){ LinkList p=L->next;int j=1;while(p&&j<i){ p=p->next;++j; }if(!p||j>i) return error;e=p->data;return ok;}Status LinkInsert(LinkList &L,int i,ElemType e) { LinkList p=L;int j=0;while(p&&j<i-1){ p=p->next;++j; }if(!p||j>i-1)return error;LinkList s=new LNode;s->data=e;s->next=p->next;p->next=s;return ok;}Status ListDelete(LinkList &L,int i,ElemType &e){ LinkList p=L;LinkList q;int j=0;while(p->next&&j<i-1){p=p->next;++j; }if(!(p->next)||j>i-1) return error;q=p->next;p->next=q->next;e=q->data;delete(q);return ok;}void MergeList(LinkList &La,LinkList &Lb,LinkList &Lc) {LinkList pa,pc,pb;pa=La->next;pb=Lb->next;Lc=pc=La;while(pa&&pb){ if(pa->data<=pb->data){ pc->next=pa;pc=pa;pa=pa->next; }else{ pc->next=pb;pc=pb;pb=pb->next; }}pc->next=pa?pa:pb;delete(Lb);}void show(LinkList L){ LinkList p;p=L->next;while(p){ cout<<p->data<<"-->";p=p->next; }cout<<endl;}int Length(LinkList L,int i){ i=0;LinkList p=L->next;while(p){ ++i;p=p->next; }return i;}void xiugai(LinkList L){ int i,j=1;ElemType k;ElemType e,m;LinkList p=L->next;cout<<"请输入要修改的元素位置(0<i<length):";cin>>i;GetElem(L,i,e);cout<<"该位置的元素:"<<e<<endl;cout<<"修改后的元素值:";cin>>k;while(p&&j<i){ p=p->next;++j; }m=p->data;p->data=k;cout<<"修改后的单链表显示如下:"<<endl;show(L);}void hebing(){ int a,b;LinkList La,Lb,Lc;cout<<"请输入第一个有序链表的长度:"<<endl;cin>>a;cout<<"请输入第一个有序链表的元素共（"<<a<<"个）："<<endl;CreateList(La,a);show(La);cout<<"请输入第二个有序链表的长度:"<<endl;cin>>b;cout<<"请输入第二个有序链表的元素共（"<<b<<"个）："<<endl;CreateList(Lb,b);show (Lb);MergeList(La,Lb,Lc);cout<<"合并后的有序链表如下："<<endl;show(Lc);}void main(){ int select;int x;ElemType y;LinkList list;for(;;){ cout<<" 单链表的基本操作"<<endl;cout<<" 1.单链表的创建"<<endl;cout<<" 2.单链表的显示"<<endl;cout<<" 3.单链表的长度"<<endl;cout<<" 4.取第i个位置的元素"<<endl;cout<<" 5.修改第i个位置的元素"<<endl;cout<<" 6.插入元素到单链表里"<<endl;cout<<" 7.删除单链表里的元素"<<endl;cout<<" 8.合并两个单链表"<<endl;cout<<" 9.退出系统"<<endl;cout<<"请选择:";cin>>select;switch(select){ case 1:cout<<"请输入单链表的长度:"<<endl;cin>>x;cout<<"请输入"<<x<<"个元素"<<endl;CreateList(list,x);break;case 2: cout<<"单链表显示如下:"<<endl;show(list);break;case 3: int s;cout<<"单链表的长度为:"<<Length(list,s)<<endl;break;case 4: cout<<"请选择所要取出元素的位置:";cin>>x;while(x<0||x>Length(list,s)){ cout<<"输入有误，请重新输入"<<endl;cout<<"请选择所要取出元素的位置:";cin>>x; }GetElem(list,x,y);cout<<"该位置的元素为:"<<y<<endl;break;case 5: xiugai(list); break;case 6: cout<<"请选择要插入的位置:"; cin>>x;while(x<0||x>Length(list,s)){ cout<<"输入有误，请重新输入"<<endl;cout<<"请选择所要插入元素的位置:";cin>>x; }cout<<"要插入的元素值:";cin>>y;LinkInsert( list,x,y);cout<<"插入后单链表显示如下:"<<endl;show(list);break;case 7: cout<<"请选择要删除的位置:"; cin>>x;while(x<0||x>Length(list,s)){ cout<<"输入有误，请重新输入"<<endl;cout<<"请选择所要删除元素的位置:";cin>>x; }ListDelete(list,x,y);cout<<"要删除的元素值:"<<y<<endl;cout<<"删除后的单链表显示如下:"<<endl;show(list);break;case 8: hebing();break;case 9: exit(0);break;default : cout<<"输入有误，请重新输入"<<endl;break;}}}6．测试结果四、实验总结（结果分析和体会）单链表的最后一个元素的next为null ,所以,一旦遍历到末尾结点就不能再重新开始;而循环链表的最后一个元素的next为第一个元素地址,可返回头结点进行重新遍历和查找。

《计算机软件技术基础》实验指导书编写：XXX适用专业：电器工程与自动化通讯工程电子信息工程安徽建筑工业学院电子与信息工程学院2007年9月实验一：线性链表的建立、查找、插入、删除实验实验学时：2实验类型：验证实验要求：必修一、实验目的通过本实验的学习，要求学生能够通过单链表的存储结构，掌握单链表的基本操作，包括单链表的建立、查找、插入、删除、输出等操作。

通过本实验可以巩固学生所学的线性表知识，提高编程能力，为后继课程的学习奠定基础。

二、实验内容1、为线性表{10，30，20，50，40，70，60，90，80，100}创建一个带头结点的单链表；2、在该链表上查找值为50，65的结点，并返回查找结果（找到：返回在县新链表中的位置）；3、在该链表上值为50的结点后，插入一个值为120的结点；4、删除该链表上值为70的结点。

写出各操作的实现函数，并上机验证。

三、实验原理、方法和手段使用带头结点的单链表的表示线性表，通过实验，熟悉链表的创建、查找、插入、删除、输出等是链表的基本操作。

具体如下：（1）首先定义单链表的节点结构；（2）在单链表创建过程中，首先初始化一个带头结点的空链表，对线性表中的各元素依次通过键盘输入、建立该元素结点、插入到单链表中，实现单链表的创建过程；结点的插入有头插入和尾插入两种方法，采用不同方法时应注意元素的输入顺序。

（3）查找过程可以从头结点开始，将待查找的数据依次与每个结点的数据域比较，匹配及查找成功，弱链表访问完未找到匹配的元素，则查找不成功。

为能够返回查找成功的结点位置，在链表的搜索过程中，应设置一个计数器，记录搜索结点的序号；（4）插入结点时，首先要通过查找算法，找到带插入结点的前驱结点，然后为带插入元素建立结点，通过指针的修改，将结点插入。

（5）删除结点时，首先要通过查找算法，找到待删除结点的前驱，然后通过指针的修改，将待删除结点从链表中卸下，释放该结点。

（6）以上操作的正确性，均可以通过链表的输出结果来验证。

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

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

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

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、操作系统：Windows 102、编程语言：C 语言3、开发工具：Visual Studio 2019三、实验原理单链表是一种常见的数据结构，它由一系列节点组成，每个节点包含数据域和指针域。

指针域用于指向下一个节点，从而形成链表的链式结构。

单链表的基本操作包括：1、创建链表：通过动态分配内存创建链表的头节点，并初始化链表为空。

2、插入节点：可以在链表的头部、尾部或指定位置插入新的节点。

3、删除节点：根据给定的条件删除链表中的节点。

4、查找节点：在链表中查找满足特定条件的节点。

四、实验内容（一）单链表的创建｀｀｀cinclude ＜stdioh>include ＜stdlibh>／／定义链表节点结构体typedef struct Node ｛int data;struct Node next;｝ Node;／／创建单链表Node createList(）｛Node head ＝（Node)malloc(sizeof(Node)）；if （head ＝＝ NULL) ｛printf(＂内存分配失败！＼n"）；return NULL;｝head>data ＝ 0;head>next ＝ NULL;return head;｝int main(）｛Node list ＝ createList(）；／／后续操作return 0;｝｀｀｀在创建单链表时，首先为头节点分配内存空间。

若内存分配失败，则提示错误信息并返回｀NULL`。

成功分配内存后，初始化头节点的数据域和指针域。

（二）单链表的插入操作插入操作分为三种情况：头部插入、尾部插入和指定位置插入。

1、头部插入｀｀｀cvoid insertAtHead(Node head, int data) ｛Node newNode ＝（Node)malloc(sizeof(Node)）；if （newNode ＝＝ NULL) ｛printf(＂内存分配失败！＼n"）；return;｝newNode>data ＝ data;newNode>next ＝ head>next;head>next ＝ newNode;｝｀｀｀头部插入时，创建新节点，将新节点的数据域赋值，并将其指针域指向原头节点的下一个节点，然后更新头节点的指针域指向新节点。

单链表的建立、插入和删除单链表的建立插入删除#include<stdio.h>#include<stdlib.h>/*线性表*/struct TLink {int data;struct TLink * next;};/*end struct TLink*//*生成新元素*/struct TLink * new_item(int number){struct TLink * r = 0;r = (struct TLink *)malloc(sizeof(struct TLink));r->data = number;r->next = 0;return r;}/*end new_item*//*在线性表中查询数据*/struct TLink * lookup(struct TLink * root, int number) {struct TLink * h = root;while(h) {if (h->data == number) return h;h = h->next ;}/*end lookup*/return 0;}/*在线性表中追加一个数据*/void append(struct TLink * * root, int number){struct TLink * r = 0, * n = 0;if (!root) return ;/*不记录重复元素*/if (lookup(*root, number)) return;/*如果表为空则新建表*/r = *root;if (!r) {*root = new_item(number);return ;}/*end if*//*为保证为有序线性表，如果数据比表头还小则作为表头*/ if (number < r->data ) {n = new_item(number);n->next = r;*root = n;return ;}/*end if*//*在有序线性表中查找位置插入元素*/while(r) {n = r->next ;/*如果已经是表尾则直接追加*/if (!n) {n = new_item(number);r->next = n;return ;}/*end if*//*在中央某处插入*/if (number < n->data ) {r->next = new_item(number);r->next->next = n;return ;}/*end if*/r = n;}/*end while*/}/*end append*//*打印有序线性表*/void print(struct TLink * root){struct TLink * r = root;printf("【");while(r) {printf("%d ", r->data );r = r->next ;}/*end while*/printf("\b】\n");}/*end print*//*将有序线性表h1合并至有序线性表h0，并销毁线性表h1*/ void merge(struct TLink ** h0, struct TLink ** h1){struct TLink * h = 0, * k = 0;if (!h0 || !h1) return ;h = *h1;while(h) {append(h0, h->data );k = h;h = h->next ;free(k);}/*end h*/h1 = 0;}int main(void){int i = 0; struct TLink * x=0, *y = 0;int a[] = {8,4,3,9,5,1};int b[] = {7,2,1,5,6,0};printf("原数据为：\n数组A：【");for(i = 0; i < 6; i++) {printf("%d ", a[i]);append(&x, a[i]);}/*next*/printf("\b】\n数组B：【");for(i = 0; i < 6; i++) {printf("%d ", b[i]);append(&y, b[i]);}/*next*/printf("\b】\n转换为有序线性表\nA：");print(x);printf("B：");print(y);printf("AB合并后为：");merge(&x, &y);print(x);return 0;}。

链表的常见操作
链表是一种常见的数据结构，其存储元素的个数是不受限定的，当要添加更多元素时，存储的个数会随之增加。

链表的操作包括但不限于以下几种：
1. 创建：链表的创建包括初始化链表、分配内存空间等操作。

2. 插入：在链表的指定位置插入一个元素。

3. 删除：删除链表中的指定元素或删除链表的指定位置的元素。

4. 查找：查找链表中是否存在指定的元素，并返回该元素的位置或指针。

5. 修改：修改链表中指定位置的元素的值。

6. 遍历：按照某种顺序遍历链表，并对每个元素进行操作。

7. 排序：按照某种规则对链表中的元素进行排序。

8. 合并：将两个已排序的链表合并成一个新的已排序链表。

9. 反转：将链表中的元素顺序反转。

10. 判断：判断链表是否为空、是否为循环链表等。

以上是链表的一些常见操作，具体实现方式会因编程语言和具体需求而有所不同。

2016级数据结构实验报告实验名称：实验一线性表——题目1学生姓名：李文超班级：2015661131班内序号：15学号：2015522147日期：2016年11月13日1.实验要求实验目的：根据线性表的抽象数据类型的定义，选择下面任一种链式结构实现线性表，并完成线性表的基本功能。

线性表存储结构（五选一）：1、带头结点的单链表2、不带头结点的单链表3、循环链表4、双链表5、静态链表线性表的基本功能：1、构造：使用头插法、尾插法两种方法2、插入：要求建立的链表按照关键字从小到大有序3、删除4、查找5、获取链表长度6、销毁7、其他：可自行定义编写测试main()函数测试线性表的正确性。

2.程序分析2.1 存储结构单链表的存储：（1）链表用一组任意的存储单元来存放线性表的结点。

这组存储单元既可以是连续的，也可以是不连续的，甚至零散地分布在内存的某些位置。

（2）链表中结点的逻辑次序和物理次序不一定相同。

为了能正确表示结点间的逻辑关系，在存储每个元素值的同时，还要存储该元素的直接后继元素的位置信息，这个信息称为指针或链。

结点结构┌──┬──┐ data 域---存放结点值的数据域│data │next │ next 域---存放结点的直接后继的地址的指针域└──┴──┘单链表在内存中的存储示意地址 内存单元1000H头指针 1020H1080H10C0H2.2 关键算法分析1、关键算法：（1）头插法自然语言描述：a:在堆中建立新结点b:将a[i]写入到新结点的数据域c:修改新结点的指针域d:修改头结点的指针域。

将新结点加入链表中伪代码描述a:Node <T> * s=new Node <T>b:s->data=a[i]c:s->next=front->next;d:front->next=s（2）尾插法自然语言描述：a:在堆中建立新结点：b:将a[i]写入到新结点的数据域：c:将新结点加入到链表中d:修改修改尾指针伪代码描述a:Node <T> * s=new Node <T>b:s->data=a[i]c:r->next=s;d:r=s（3）遍历打印函数自然语言描述：a:判断该链表是否为空链表，如果是，报错b:如果不是空链表，新建立一个temp指针c:将temp指针指向头结点d:打印temp指针的data域e:逐个往后移动temp指针，直到temp指针的指向的指针的next域为空伪代码描述a: If front->next==NULL①Throw ”an empty list ”②Node<T>* temp=front->next;b:while(temp->next)c:cout<<temp->data<<" ";d:temp=temp->next;(4) 获取链表长度函数自然语言描述：a:判断该链表是否为空链表，如果是，输出长度0b:如果不是空链表，新建立一个temp指针，初始化整形数n为0c:将temp指针指向头结点d:判断temp指针指向的结点的next域是否为空，如果不是，n加一，否则return ne: 使temp指针逐个后移，重复d操作，直到temp指针指向的结点的next域为0，返回n伪代码描述a:if ront->next==NULLb:Node<T>* temp=front->next;c:while(temp->next)d:temp=temp->next;（5）析构/删除函数自然语言描述：a:新建立一个指针，指向头结点b:判断要释放的结点是否存在，c:暂时保存要释放的结点d:移动a中建立的指针e:释放要释放的指针伪代码描述a:Node <T> * p=frontb:while(p)c:front=pd:p=p->nexte:delete front（6）按位查找函数自然语言描述：a:初始化工作指针p和计数器j，p指向第一个结点，j=1b:循环以下操作，直到p为空或者j等于1①：p指向下一个结点②：j加1c:若p为空，说明第i个元素不存在，抛出异常d:否则，说明p指向的元素就是所查找的元素，返回元素地址伪代码描述a:Node <T> * p=front->next;j=1;b:while(p&&j!=1)①:p=p->next②:j++c:if(!p) throw ”error”d:return p（7）按位查找函数自然语言描述：a:初始化工作指针p和计数器j，p指向第一个结点，j=1b:循环以下操作，找到这个元素或者p指向最后一个结点①：判断p指向的结点是不是要查找的值，如果是，返回j，否则p指向下一个结点，并且j的值加一c:如果找到最后一个结点还没有找到要查找的元素，返回查找失败信息伪代码描述a:Node <T> * p=front->next;j=1;b:while(p)①: if(p->next==x) return jp=p->nextj++c:return “error”（8）插入函数自然语言描述：a:在堆中建立新结点b:将要插入的结点的数据写入到新结点的数据域c:修改新结点的指针域d:修改前一个指针的指针域，使其指向新插入的结点的位置伪代码描述a:Node <T> * s=new Node <T>;b:s-data=p->datac:s->next=p->nextd:p->next=se:p->data=x（9）删除函数自然语言描述：a:从第一个结点开始，查找要删除的位数i前一个位置i-1的结点b:设q指向第i个元素c:将q元素从链表中删除d:保存q元素的数据e:释放q元素伪代码描述a:q=p->nextb:p->next=q->nextc:x=q->datad:delete q2、代码详细分析（插入）：（1）从第一个结点开始，查找节点，使它的数据比x大，设p指向该结点：while (x>p->data) { p=p->next;}（2）新建一个节点s，把p的数据赋给s：s->data=p->data;（3）把s加到p后面：s->next=p->next; p->next=s;（4）p节点的数据用x替换：p->data=x;示意图如图所示xp->datas3、关键算法的时间复杂度：O（1)3.程序运行结果1. 流程图：2、结果截图3.测试结论：可以正确的对链表进行插入，删除，取长度，输出操作。