pta 单链表基本操作

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

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;}。

数据结构单链表单链表是一种常见的数据结构，用于存储数据元素之间的线性关系。

本文将介绍单链表的定义、基本操作、常见问题以及优缺点。

⒈定义单链表是由一系列节点组成的数据结构，每个节点包含了一个数据元素和一个指向下一个节点的指针。

⒉基本操作⑴创建链表：通过动态分配内存空间创建一个链表，并将其头指针指向第一个节点。

⑵插入节点：插入一个新节点到链表的指定位置，需要更新相关节点的指针。

⑶删除节点：删除链表中的一个指定节点，需要更新相关节点的指针和释放内存空间。

⑷遍历链表：按顺序访问链表中的每个节点，并对其进行相应操作。

⑸查找节点：在链表中查找指定值的节点，并返回其位置或其他信息。

⒊常见问题⑴求链表的长度：遍历整个链表，并将节点计数即可获取链表的长度。

⑵反转链表：通过修改节点之间的指针关系反转链表的顺序。

⑶判断链表是否有环：使用快慢指针法，若两个指针相遇则链表有环。

⑷合并两个有序链表：比较两个链表的节点值，逐个合并到一个新链表中。

⑸删除链表中重复的元素：遍历链表，对相邻的节点进行比较，若值相同则删除后一个节点。

⒋优缺点⑴优点：插入和删除节点的时间复杂度为O(1)，只需要改变指针指向。

链表大小可以动态调整。

⑵缺点：访问节点的时间复杂度为O(n)，需要从头节点开始遍历整个链表。

需要额外的空间用于存储指针。

附件：- 单链表的示例代码（见附件1）- 单链表的应用实例（见附件2）法律名词及注释：⒈数据结构：指数据对象中数据元素之间的关系，包括逻辑结构和物理结构。

⒉单链表：一种线性链式存储结构，每个节点包含数据元素和指向下一个节点的指针。

⒊节点：链表中的一个元素，包含数据元素和指针。

⒋头指针：指向链表中第一个节点的指针。

⒌快慢指针法：一种用于解决链表问题的常用技巧，通过设置两个不同速度的指针来判断是否存在环。

主题：pta单链表元素最大值以及结点数一、简介pta是一个上线评测系统，专门用于评测程序设计能力。

在pta中，关于单链表的问题广泛存在，而求单链表中元素最大值以及结点数也是一种常见的问题。

二、绪论单链表是一种常见的数据结构，由一系列结点组成，每个结点包含数据域和指针域。

求单链表中元素的最大值以及结点数是对链表基本操作的考察，也是对算法思维和编程能力的考验。

三、元素最大值的求解1. 遍历法：最简单直接的方法是使用遍历法，从链表的头结点开始，一直遍历到尾部结点，记录下遍历过程中所遇到的最大值，即可得到单链表中元素的最大值。

该方法的时间复杂度为O(n)，n为链表的长度。

2. 递归法：另一种方法是使用递归法，递归地比较每个结点的值，并更新最大值。

该方法也能够得到单链表中元素的最大值，但是相比于遍历法，递归法的实现可能会更加复杂，而且在链表长度过大时可能会导致栈溢出。

3. 思考：对于单链表中元素最大值的求解，还可以考虑是否可以借助其他数据结构，如堆或者优先队列，来实现更加高效的求解方法。

这需要对数据结构与算法进行综合考虑与分析。

四、结点数的求解1. 遍历法：同样可以使用遍历法来求解单链表的结点数，从链表的头结点开始，一直遍历到尾部结点，在遍历过程中记录下结点的个数即可。

该方法的时间复杂度同样为O(n)。

2. 递归法：类似地，也可以使用递归法来逐个遍历结点，并更新结点个数。

但是同样需要注意在链表长度过大时可能会出现栈溢出的情况。

3. 思考：对于单链表中结点数的求解，是否可以通过对链表的结构进行改造或者引入新的数据结构，来实现更加高效的求解方法也是值得思考的问题。

五、总结求解单链表中元素最大值以及结点数是一个基础的算法问题，也是对程序设计能力的考验。

在实际工作中，对于常用数据结构的基本操作，如单链表的遍历与求解问题，需要熟练运用常见的解题方法，同时也需要培养自己发现问题、分析问题和解决问题的能力。

六、参考资料1. 《算法导论》2. 《数据结构与算法分析》3. 《程序设计导论》七、致谢感谢各位老师和同学在我学习和工作中给予的帮助与支持，让我不断提高自己的算法与编程能力。

链表基本操作
链表是一种常用的数据结构，它由一系列结点组成，每个结点包含一个数据元素和一个指向后继结点的指针。

链表的基本操作包括插入、删除、查找和遍历。

插入操作可以在链表的任意位置插入一个新的结点；删除操作可以删除链表中的任意一个结点；查找操作可以在链表中查找指定的数据元素；遍历操作可以依次访问链表中的所有结点。

链表的优点是可以动态地增加或删除数据元素，但是它的缺点是访问任意一个结点的时间复杂度是O(n)，不如数组的O(1)高效。

因此，链表常常用于需要频繁插入或删除数据元素的场合，例如实现栈、队列等数据结构。

- 1 -。

单链表的基本操作(C语言)什么是单链表单链表（Singly Linked List）是一种常见的数据结构，它由一系列节点组成，每个节点包含一个数据元素和一个指向下一个节点的指针。

每个节点只能访问其后继节点，而无法直接访问前驱节点。

单链表的特点是可以动态地插入和删除节点，相比于数组，具有更好的灵活性和扩展性。

在C语言中，我们可以使用指针来实现单链表。

单链表的基本操作1. 定义单链表结构体在C语言中，我们首先需要定义一个表示单链表的结构体。

结构体包含两个成员：数据元素和指向下一个节点的指针。

typedef struct Node {int data; // 数据元素struct Node *next; // 指向下一个节点的指针} Node;2. 创建单链表创建一个空的单链表需要进行以下步骤：•定义头节点，并初始化为NULL。

•向链表中插入新的节点。

Node* createLinkedList() {Node *head = NULL; // 头节点初始化为NULLint n; // 节点数量printf("请输入要创建的节点数量：");scanf("%d", &n);for (int i = 0; i < n; i++) {int data;printf("请输入第%d个节点的值：", i + 1);scanf("%d", &data);Node *newNode = (Node*)malloc(sizeof(Node)); // 创建新节点newNode->data = data;newNode->next = NULL;if (head == NULL) {head = newNode; // 如果是第一个节点，将其设置为头节点 } else {Node *temp = head;while (temp->next != NULL) {temp = temp->next; // 移动到链表末尾}temp->next = newNode; // 将新节点插入到链表末尾}}return head;}3. 插入节点在单链表中插入一个新的节点需要进行以下步骤：•创建一个新的节点。

实验一单链表的基本操作一．要求：（1）依次从键盘读入数据，建立带头结点的单链表；（2）输出单链表中的数据元素（3）求单链表的长度；（4）根据指定条件能够取元素和修改元素；（5）实现在指定位置插入和删除元素的功能。

二：算法设计：（1）用到的结构：逻辑结构（循环结构，条件结构，顺序结构）存储结构（线性单链表）（2）算法设计思路：首先利用尾插发创建一个单链表status createlist(LinkList &L)然后通过void print(LinkList L)方法输出，通过int ListLength(LinkList L)方法得到链表的长度，通过char GetElem(LinkList L,int i)方法，当第i 个元素存在时，其值赋给e并返回，然后通过status ListInsert(LinkList &L,int i,ElemType e) 在头结点单链线性表L中第i个位置之前插入元素e，最后通过status ListDelete(LinkList &L,int i) 删除L中第i个元素，并用e 返回其值。

三：调试和测试：（1）调试过程总结：这些是对但链表的基本操作，算是对单链表的总结。

C++不同于java，需要定义如OK，false等。

还有有的包没有正确的引入。

（2）三组测试数据及实验结果：第一组：测试ascxzbn第二组：测试dbcmgkfko第三组：测试oehfdklsdjsk实验二回文判断一实验要求：（1）数据从键盘读入；（2）输出要判断的字符串；（3）利用栈的基本操作对给定的字符串判断其是否是回文，若是则输出“Yes”，否则输出“No”。

二：算法设计：（1）用到的结构：逻辑结构（循环结构，条件结构，顺序结构）存储结构（链式栈）（2）算法设计思路：先创建一个栈的大小为100，然后用void InitStack( SeqStack *S)方法初始化一个空栈，紧接着用int EmptyStack(SeqStack *S)还有int FullStack (SeqStack *S)分别判断栈是空还是满。

单向链表单向链表的基本操作,创建一个由6个节点组成的单向链表，显示链表中每个节点的数据，并且做增加、删除、查找节点以及计算单链表的长度等处理。

➢需求分析：1.功能（1）用尾插法创建一带头结点的由6个节点组成的单向链表：从键盘读入一组整数，作为单链表中的元素，输入完第6个结点后结束;将创建好的单链表元素依次输出到屏幕上。

（2）显示链表中每个节点的数据（3）从键盘输入一个数,查找在以上创建的单链表中是否存在该数；如果存在,显示它的位置，即第几个元素;如果不存在，给出相应提示如“No found node!”。

（4）在上述的单链表中的指定位置插入指定数据，并输出单链表中所有数据。

(5）删除上述单链表中指定位置的结点，并输出单链表中所有数据。

(6）求单链表的长度并输出.2．输入要求先输入单链表中结点个数n,再输入单链表中所有数据，在单链表中需查找的数据，需插入的数据元素的位置、值，要删除的数据元素的位置。

3。

测试数据单链表中所有数据：12，23,56，21，8，10在单链表中需查找的数据：56；24插入的数据元素的位置、值：1，28；7,28；0，28要删除的数据元素的位置:6➢概要设计：1.算法思想：由于在操作过程中要进行插入、删除等操作，为运算方便，选用带头结点的单链表作数据元素的存储结构.对每个数据元素，由一个数据域和一个指针域组成，数据域放输入的数据值，指针域指向下一个结点。

2.数据结构：单链表结点类型:typedef struct Liistnode ｛int data；struct Listnode *next;｝NODE;3.模块划分：a)用尾插法建立带头结点的单链表＊CreateList函数；b)显示链表中每个结点的数据PrintList函数;c)从键盘输入一个数，查找单链表中是否存在该数FoundList函数；d)在单链表中指定位置插入指定数据并输出单链表中所有数据InsertList函数;e)删除单链表中指定位置的结点并输出单链表中所有数据DeleteList函数；f)计算单链表的长度并在屏幕上输出LengthList函数;g)主函数main()，功能是给出测试数据值，建立测试数据值的带头结点的单链表,调用PrintList函数、FoundList函数、InsertList函数、DeleteList函数、LengthList函数实现问题要求。

单链表的基本操作（查找，插⼊，删除）这周⽼师给的作业跟上周貌似差不多。

只是⽤了单链表。

完成单链表的基本操作函数。

1) 初始化单链表2) 给定的数据元素存放在⼀维数组中，分别完成头插法和尾插法建⽴单链表3) 将数据元素从键盘依次输⼊，分别完成头插法和尾插法建⽴单链表4) 输出单链表的长度5) 实现按位查找和按值查找6) 实现插⼊和删除操作7) 实现遍历单链表操作#include <cstdio>#include <cstring>#include <cstdlib>//查找1.内容2.序号//插⼊//删除typedef struct student{int num;char name[10];}STU;typedef struct Node{STU data;struct Node * next;}Node;void denglu(Node *L);//登录函数void chazhao(Node *L);//查找函数void Printf(Node *L);//输出函数void CreateFromHead(Node *L);//头插法void CreateFormTail(Node *L);//尾插法void panduan(Node *L);//判断头插还是尾插void Get(Node *L);//按序号结点查找void Locate(Node *L);//按内容查找（值）void Inslist(Node *L);//插⼊void Dellist(Node *L);//删除void Dellist(Node *L)//删除{system("CLS");int n;printf("请输⼊要删除的结点\n");scanf("%d",&n);if(n<=0){printf("输⼊的数据不合法,请重新输⼊\n");Dellist(L);}Node *pre,*r;int k=0;pre=L;while(pre->next !=NULL&&k<n-1){pre=pre->next;k=k+1;}if(pre->next==NULL){printf("没有找到该结点,请重新输⼊\n");Dellist(L);}r=pre->next;pre->next=r->next;free(r);printf("删除成功!\n");denglu(L);}void Inslist(Node *L)//插⼊{system("CLS");int n;printf("请输⼊在第⼏个位置插⼊数据\n");scanf("%d",&n);printf("请输⼊插⼊的学号,姓名\n");int num1;char name1[10];scanf("%d %s",&num1,name1);Node *pre,*s;int k=0;if(n<=0){printf("输⼊的数据不合法,请重新输⼊\n");Inslist(L);}pre=L;while(pre!=NULL&&k<n-1){pre=pre->next;k=k+1;}if(pre==NULL){printf("⽆法找到该节点,请重新输⼊\n");Inslist(L);}s=(Node*)malloc(sizeof(Node));strcpy(s->data .name ,name1);s->data.num=num1;s->next =pre->next ;pre->next =s;printf("插⼊成功!\n");denglu(L);}void Locate(Node *L)//按内容查找（值）{system("CLS");int n;printf("请输⼊要查找的学号\n");scanf("%d",&n);Node *p;p=L->next;while(p!=NULL){if(p->data.num!=n){p=p->next;}elsebreak;}printf("你要查找的学号所对应的信息为%d %s\n",p->data.num,p->);denglu(L);}void Get(Node *L)//按序号结点查找{system("CLS");int n;printf("请输⼊你要查找的结点\n");scanf("%d",&n);if(n<=0){printf("输⼊的数据不合法,请重新输⼊\n");Get(L);}Node *p;p=L;int j=0;while((p->next!=NULL)&&(j<n)){p=p->next;j++;}if(n==j){printf("你要查找的结点的储存位置的数据为%d %s\n",p->data.num,p->); }denglu(L);}void Printf(Node *L){int q=0;Node *p=L->next;while(p!=NULL){q++;printf("%d %s\n",p->data.num,p->); p=p->next;}printf("单链表长度为%d\n",q);denglu(L);}void chazhao(Node *L){printf("1.按序号查找\n");printf("2.按内容查找\n");printf("3.返回主界⾯\n");int aa;scanf("%d",&aa);switch(aa){case 1:Get(L);case 2:Locate(L);case 3:denglu(L);break;default:printf("输⼊错误请重新输⼊\n");chazhao(L);}}void denglu(Node *L){int a;printf("请选择你要做什么\n");printf("1.查找\n");printf("2.插⼊\n");printf("3.删除\n");printf("4.打印现有的学⽣信息及单链表长度\n"); printf("5.退出\n");scanf("%d",&a);switch(a){case 1:chazhao(L);case 2:Inslist(L);case 3:Dellist(L);case 4:Printf(L);case 5:printf("谢谢使⽤\n");exit(0);default:printf("输⼊错误请重新输⼊\n");denglu(L);}}void CreateFromHead(Node *L)//头插法{Node *s;int n;//n为元素个数printf("请输⼊元素个数\n");scanf("%d",&n);printf("请输⼊学号姓名\n");for(int i=1;i<=n;i++){s=(Node *)malloc(sizeof(Node));scanf("%d %s",&s->data.num,s->); s->next=L->next;L->next=s;}}void CreateFormTail(Node *L)//尾插法{Node *s,*r;r=L;int n;//n为元素个数printf("请输⼊元素个数\n");scanf("%d",&n);printf("请输⼊学号姓名\n");for(int i=1;i<=n;i++){s=(Node *)malloc(sizeof(Node));scanf("%d %s",&s->data.num,s->);r->next=s;r=s;if(i==n){r->next=NULL;}}}Node *InitList(Node *L)//初始化单链表{L=(Node *)malloc(sizeof(Node));L->next=NULL;return L;}void panduan(Node *L){int q;printf("请选择⽤哪种⽅式建⽴链表\n");printf("1.头插法\n");printf("2.尾插法\n");scanf("%d",&q);switch(q){case (1):CreateFromHead(L);printf("输⼊成功！\n");break;case (2):CreateFormTail(L);printf("输⼊成功！\n");break;default:printf("输⼊错误请重新输⼊\n");panduan(L);}}int main(){Node *L=NULL;L=InitList(L);panduan(L);denglu(L);return 0;}ps.贴上来的代码空格有点⼩奇怪啊。

3)总结使用单链表的一般步骤。

单链表是一种经常在编程中使用的数据结构，它由一系列节点组成，每个节点包含一个数据元素和一个指向下一个节点的指针。

在使用单链表的时候，我们通常需要按照以下步骤进行操作。

1. 定义节点结构首先，我们需要定义单链表中每个节点的结构。

节点结构一般包含两个部分：数据元素和指向下一个节点的指针。

我们可以使用结构体来定义节点结构，并根据实际需求定义节点中数据的类型。

2. 创建头节点头节点是单链表中的第一个节点，它不存储实际的数据元素，只是作为链表的入口。

在创建单链表时，我们需要先创建一个头节点，并将其指针指向NULL，表示当前链表为空。

3. 添加节点在单链表中添加节点的操作通常分为两种情况：在链表头部添加节点和在链表尾部添加节点。

如果要在链表头部添加节点，我们只需要将新节点的指针指向原头节点，并将头节点指针指向新节点即可。

如果要在链表尾部添加节点，我们需要遍历链表直到找到最后一个节点，然后将最后一个节点的指针指向新节点，并将新节点的指针指向NULL。

4. 删除节点在单链表中删除节点的操作通常也分为两种情况：删除链表头部的节点和删除链表中间的节点。

如果要删除链表头部的节点，我们只需要将头节点指针指向下一个节点，并释放原头节点的内存空间即可。

如果要删除链表中间的节点，我们需要先找到要删除节点的前一个节点，然后将前一个节点的指针指向要删除节点的下一个节点，并释放要删除节点的内存空间。

5. 遍历链表遍历链表是指按照一定的顺序访问链表中的每个节点。

我们可以使用循环来遍历链表，从头节点开始，依次访问每个节点，并根据实际需求对节点进行操作。

6. 查找节点在单链表中查找节点的操作通常有两种情况：按照位置查找节点和按照值查找节点。

如果要按照位置查找节点，我们可以使用循环遍历链表，直到找到指定位置的节点。

如果要按照值查找节点，我们需要使用循环遍历链表，并比较每个节点中的数据元素，直到找到指定值的节点。

链表基本操作
链表是一种常见的数据结构，它由一系列节点组成，每个节点都包含了一个数据元素和指向下一个节点的指针。

链表的基本操作包括插入、删除和遍历。

插入操作可以在链表的头部、尾部或指定位置插入一个新节点。

删除操作可以删除链表中某个节点，也可以删除整个链表。

遍历操作可以遍历整个链表，访问每个节点的数据元素。

链表的优点在于可以动态地添加或删除节点，而不必预先分配固定大小的内存空间。

然而，链表的缺点是访问节点时需要从头部开始遍历，效率比数组低。

链表是许多其他数据结构的基础，例如队列、栈和哈希表等。

理解链表的基本操作对于深入理解这些数据结构是至关重要的。

- 1 -。

实现单链表的各种基本运算
单链表是一种重要的数据结构，在实际开发中应用广泛。

实现单链表的各种基本运算是数据结构学习的必备内容。

其中，包括单链表的创建、插入、删除、查找以及遍历等操作。

首先，单链表的创建需要定义单链表节点的结构体，并通过malloc函数动态分配节点内存。

然后，将各个节点通过指针相连，形成链表。

其次，单链表的插入操作可以在链表的任意位置插入新节点。

具体实现方式是，先通过遍历找到待插入节点的位置，然后将新节点插入到该位置前面即可。

再次，单链表的删除操作可以删除任意位置的节点。

具体实现方式是，先通过遍历找到待删除节点的位置，然后将其前一个节点的指针指向其后一个节点，再通过free函数释放该节点的内存即可。

另外，单链表的查找操作可以通过遍历实现。

对于有序链表，还可以采用二分查找法提高查找效率。

最后，单链表的遍历操作可以通过while循环遍历整个链表，依次输出每个节点的值。

总之，实现单链表的基本运算是数据结构学习中非常重要的一部分。

掌握了这些操作，可以为日后的开发工作打下坚实的基础。

- 1 -。

单链表的实现及其基本操作结点的引⼊链表是⼀种链式存储结构，链式存储结构的特点是⽤⼀组任意的存储单元存储数据元素。

为了能正确表⽰数据元素之间的线性关系，需引⼊结点概念。

⼀个结点表⽰链表中的⼀个数据元素，节点中除了储存数据元素的信息，还必须存放指向下⼀个节点的的指针（单、双链表的最后⼀个节点除外，它们存储的是⼀个空指针NULL）结点的结构如下图所⽰：代码如下：1 typedef struct node{2int data;3struct node* pNext;4 }Node, *PNode;View Code注：这⾥假设结点中储存的是整型 (int) 的数据单链表由多个结点依次连接⽽成，我们不难想象出它结构：我们注意到：在第⼀个结点的前⾯多了⼀个头结点，这是为了处理空表的⽅便⽽引⼊的，它的指针指向链表的第⼀个结点，⽽它的data域不存放任何信息。

单链表的基本操作1.创建链表1 PNode createList()2 {3int len, value;45 PNode pHead = (PNode)(malloc(sizeof(Node)));6 PNode pTail = pHead;7 pTail->pNext = NULL;89 printf("请输⼊你要的节点个数：");10 scanf("%d", &len);11for(int i=1;i<=len;i++){12 printf("请输⼊第%d个节点的值：", i);13 scanf("%d", &value);1415 PNode pNew = (PNode)malloc(sizeof(Node));16 pNew->data = value;17 pTail->pNext = pNew;18 pTail = pNew;19 pTail->pNext = NULL;20 }2122return pHead;23 }View Code2.遍历链表void traverse(PNode pHead){printf("遍历结果为:\n");PNode pTra = pHead;while(pTra->pNext != NULL){printf("%d ", pTra->pNext->data);pTra = pTra->pNext;}printf("\n");}View Code3.判断链表是否为空1bool isEmpty(PNode pHead)2 {3if(pHead->pNext==NULL)4return true;5else6return false;7 }View Code4.链表长度1int length(PNode pHead)2 {3int len = 0;4while(pHead->pNext!=NULL){5 pHead = pHead->pNext;6 len++;7 }8return len;910 }View Code5.插⼊结点1bool insert(PNode pHead, int pos, int val)2 {3if(pos<1 || pos>length(pHead)){4return false;5 }else{6 PNode pInsert = pHead;7for(int i=1;i<pos;i++){8 pInsert = pInsert->pNext;9 }1011 PNode pNew = (PNode)malloc(sizeof(Node));12 pNew->data = val;13 pNew->pNext = pInsert->pNext;14 pInsert->pNext = pNew;1516return true;17 }1819 }View Code6.删除结点1bool del(PNode pHead, int pos)2 {3if(pos<1 || pos>length(pHead)){4return false;5 }else{6 PNode pDel = pHead;7for(int i=1;i<pos;i++){8 pDel = pDel->pNext;9 }1011if(pos==length(pHead)){12free(pDel->pNext);13 pDel->pNext = NULL;14 }else{15 PNode pNext = pDel->pNext->pNext;16free(pDel->pNext);17 pDel->pNext = pNext;18 }1920return true;2122 }232425 }View Code7.查找节点（1）按元素值查找1 PNode locate(PNode pHead, int value)2 {3 PNode p = pHead->pNext;4while(p&&p->data!=value){ //NULL 是 05 p = p->pNext;6 }7return p;8 }View Code（2）按序号查找1 PNode get(PNode pHead, int k)2 {3 PNode p = pHead;4for(int i=1;i<=k;i++){5 p = p->pNext;6 }7return p;89 }View Code完整代码1 #include<stdio.h>2 #include<stdlib.h>3 typedef struct node{4int data;5struct node* pNext;6 }Node, *PNode;78 PNode createList();9void traverse(PNode pHead);10bool isEmpty(PNode pHead);11int length(PNode pHead);12bool insert(PNode pHead, int pos, int val);13bool del(PNode pHead, int pos);14 PNode get(PNode pHead, int k); //按序号查找15 PNode locate(PNode pHead, int value);//按值查找 1617int main(void)18 {19//test2021return0;22 }2324 PNode createList()25 {26int len, value;2728 PNode pHead = (PNode)(malloc(sizeof(Node)));29 PNode pTail = pHead;30 pTail->pNext = NULL;3132 printf("请输⼊你要的节点个数：");33 scanf("%d", &len);34for(int i=1;i<=len;i++){35 printf("请输⼊第%d个节点的值：", i);36 scanf("%d", &value);3738 PNode pNew = (PNode)malloc(sizeof(Node));39 pNew->data = value;40 pTail->pNext = pNew;41 pTail = pNew;42 pTail->pNext = NULL;43 }4445return pHead;46 }474849void traverse(PNode pHead)50 {51 printf("遍历结果为:\n");52 PNode pTra = pHead;53while(pTra->pNext != NULL)54 {55 printf("%d ", pTra->pNext->data);56 pTra = pTra->pNext;57 }58 printf("\n");59 }6061bool isEmpty(PNode pHead)62 {63if(pHead->pNext==NULL)64return true;65else66return false;67 }6869int length(PNode pHead)70 {71int len = 0;72while(pHead->pNext!=NULL){73 pHead = pHead->pNext;74 len++;75 }76return len;7778 }7980bool insert(PNode pHead, int pos, int val)81 {82if(pos<1 || pos>length(pHead)){83return false;84 }else{85 PNode pInsert = pHead;86for(int i=1;i<pos;i++){87 pInsert = pInsert->pNext;88 }8990 PNode pNew = (PNode)malloc(sizeof(Node));91 pNew->data = val;92 pNew->pNext = pInsert->pNext;93 pInsert->pNext = pNew;9495return true;96 }9798 }99100bool del(PNode pHead, int pos)101 {102if(pos<1 || pos>length(pHead)){103return false;104 }else{105 PNode pDel = pHead;106for(int i=1;i<pos;i++){107 pDel = pDel->pNext;108 }109110if(pos==length(pHead)){111free(pDel->pNext);112 pDel->pNext = NULL;113 }else{114 PNode pNext = pDel->pNext->pNext;115free(pDel->pNext);116 pDel->pNext = pNext;117 }118119return true;120121 }122123124 }125126 PNode get(PNode pHead, int k)127 {128 PNode p = pHead;129for(int i=1;i<=k;i++){130 p = p->pNext;131 }132return p;133134 }135 PNode locate(PNode pHead, int value)136 {137 PNode p = pHead->pNext;138while(p&&p->data!=value){ //NULL 是 0 139 p = p->pNext;140 }141return p;142 }View Code。

单链表的建立与基本操作python单链表是一种常用的数据结构，可以用来存储线性数据。

单链表具有以下特点：- 每个节点只有一个指针，指向下一个节点，最后一个节点的指针为None。

-节点之间在物理上不必相连，只需要通过指针来连接。

-单链表的优点是插入和删除操作都很快，时间复杂度为O(1)，但是查找操作比较慢，时间复杂度为O(n)。

下面是单链表的建立与基本操作的Python代码实现：##定义单链表节点。

class Node:。

def __init__(self, data=None, next=None):。

self.data = data 。

self.next = next 。

##定义单链表类。

class LinkedList:。

def __init__(self):。

self.head = None 。

##添加节点。

def append(self, data):。

if not self.head:。

self.head = Node(data=data)。

return。

current = self.head。

while current.next:。

current = current.next。

current.next = Node(data=data)。

##删除节点。

def remove(self, key):。

current = self.head。

prev = None。

while current and current.data != key:。

prev = current。

current = current.next。

if prev is None:。

self.head = current.next。

elif current:。

prev.next = current.next。

current.next = None。

##获取链表长度。

def get_length(self):。

current = self.head。

单链表的基本操作实现1. 单链表含头结点模型⽰意图如下：2. 单链表节点结构定义如下：struct ListNode {int val;ListNode* next;ListNode(int x) : val(x), next(NULL) {}};3. 单链表的基本操作函数如下：ListNode* createList(); // ⼿动输⼊创建⼀个链表void printList(ListNode* head); // 打印链表数据int getListLength(ListNode* head); // 获取链表长度ListNode* insertList(ListNode* head, int pos, int data); // 插⼊数据到链表⾥ListNode* deleteList(ListNode* head, int pos); // 删除链表节点数据4. 具体代码实现如下：#include <iostream>using namespace std;struct ListNode {int val;ListNode* next;ListNode(int x) : val(x), next(NULL) {}};ListNode* createList() {ListNode* head = new ListNode(0);ListNode* p = head;ListNode* node = NULL;int flag = 1;int data = 0;while (flag) {cout << "Please input the data: " << endl;cin >> data;if (data != 0) {node = new ListNode(data);p->next = node;p = node;}else {flag = 0;}}return head;}void printList(ListNode* head) {if (head == NULL || head->next == NULL) {cout << "The list is empty!" << endl;return;}ListNode* p = head->next;cout << "The list values are as follows: " << endl;while (p != NULL) {cout << p->val << " ";p = p->next;}cout << endl;}int getListLength(ListNode* head) {if (head == NULL || head->next == NULL) {cout << "The list is empty!" << endl;return 0;}ListNode* p = head->next;int len = 0;while (p != NULL) {len++;p = p->next;}return len;}ListNode* insertList(ListNode* head, int pos, int data) {if (pos <= 0) {cout << "The pos is error!" << endl;return head;}if (head == NULL) {head = new ListNode(0);}ListNode* p = head;int index = 1;while (p != NULL && index < pos) {p = p->next;index++;}ListNode* node = new ListNode(data);if (p != NULL) {node->next = p->next;p->next = node;}return head;}ListNode* deleteList(ListNode* head, int pos) {if (pos <= 0) {cout << "The pos is error!" << endl;return head;}if (head == NULL || head->next == NULL) {cout << "The list is empty!" << endl;return head;}ListNode* p = head;int index = 1;while (p != NULL && index < pos) {p = p->next;index++;}if (p != NULL && p->next != NULL) {ListNode* temp = p->next;p->next = temp->next;delete temp;}return head;}int main() {ListNode* head = NULL;head = createList();printList(head);insertList(head, 3, 300);printList(head);deleteList(head, 5);printList(head);cout << "The length of the list is " << getListLength(head) << endl; system("pause");return 0;}5. 运⾏结果截图如下：。