单链表的应用

目录1 选题背景 (1)2 方案与论证 (1)2。

1 链表的概念和作用 (1)2。

3 算法的设计思想 (2)2。

4 相关图例 (3)2.4.1 单链表的结点结构 (3)2.4。

2 算法流程图 (3)3 实验结果 (4)3.1 链表的建立 (4)3.2 单链表的插入 (4)3.3 单链表的输出 (5)3.4 查找元素 (5)3。

5 单链表的删除 (5)3。

6 显示链表中的元素个数（计数) (5)4 结果分析 (6)4。

1 单链表的结构 (6)4。

2 单链表的操作特点 (6)4。

2。

1 顺链操作技术 (6)4.2。

2 指针保留技术 (6)4。

3 链表处理中的相关技术 (6)5 设计体会及今后的改进意见 (6)参考文献 (8)附录代码： (8)1 选题背景陈火旺院士把计算机60多年的发展成就概括为五个“一”：开辟一个新时代-—--信息时代,形成一个新产业-—-—信息产业,产生一个新科学—---计算机科学与技术，开创一种新的科研方法-—--计算方法，开辟一种新文化---—计算机文化，这一概括深刻影响了计算机对社会发展所产生的广泛而深远的影响。

数据结构和算法是计算机求解问题过程的两大基石。

著名的计算机科学家P.Wegner指出，“在工业革命中其核心作用的是能量,而在计算机革命中其核心作用的是信息”.计算机科学就是“一种关于信息结构转换的科学”.信息结构（数据结构）是计算机科学研究的基本课题，数据结构又是算法研究的基础。

2 方案与论证2。

1 链表的概念和作用链表是一种链式存储结构，链表属于线性表,采用链式存储结构，也是常用的动态存储方法。

链表中的数据是以结点来表示的，每个结点的构成:元素（数据元素的映象） + 指针(指示后继元素存储位置)，元素就是存储数据的存储单元,指针就是连接每个结点的地址数据。

以“结点的序列”表示线性表称作线性链表（单链表)单链表是链式存取的结构，为找第 i 个数据元素，必须先找到第 i-1 个数据元素。

单链表应⽤之稀疏多项式求和（C语⾔）采⽤归并思想计算两个多项幂式之和，这⾥有两个化简好的关于x的多项幂式：A(x)=7+3x+9x^8+5x^17+2x^20；B(x)=8x+22x^7-9x^8-4x^17，⽤C语⾔实现两多项式数据的存储，并求两者的和Y(x)。

之所以称之为稀疏多项式，是因为多项式中各项x的指数部分不连续，且相差较⼤，故编程实现该类多项式存储时可考虑链式存储，提升空间利⽤率。

完整代码如下：#include <stdio.h>#include <stdlib.h>/*** 含头节点单链表应⽤之稀疏多项式相加：* A(x)=7+3x+9x^8+5x^17+2x^20* B(x)=8x+22x^7-9x^8-4x^17* 求：Y(x)=A(x)+B(x)*///基本操作函数⽤到的状态码#define TRUE 1;#define FALSE 0;#define OK 1;#define ERROR 0;//Status是新定义的⼀种函数返回值类型，其值为int型typedef int Status;//数据元素类型typedef struct {int coe; //系数int exp; //指数} ElemType;//单链表定义typedef struct Lnode {ElemType data; //数据域struct Lnode *next; //指针域} Lnode, *LinkList;//基本操作1：单链表初始化Status InitList(LinkList *list) {(*list)=(LinkList)malloc(sizeof(Lnode));(*list)->next=NULL;return OK;}//基本操作11：头插法建⽴链表，数据已保存在ElemType类型的数组中Status CreateList_H(LinkList *list,ElemType arrData[],int length) {int j;for(j=length-1;j>=0;j--){//新建结点Lnode *node;node=(Lnode*)malloc(sizeof(Lnode));node->data=arrData[j];node->next=NULL;//插⼊为1号结点node->next=(*list)->next;(*list)->next=node;}return OK;}//基本操作13：链表元素遍历输出Status ListTraverse(LinkList list) {Lnode *p;p=list;int j=0;printf("序号：系数：指数：\n");while(p->next){j++;p=p->next;printf("(%d) %d %d\n",j,(p->data).coe,(p->data).exp);}printf("\n");return OK;}//多项式求和, pa、pb、pc分别指向listA、listB、合并后新链表的当前结点Status GetPolynthicSum(LinkList *listA,LinkList *listB){Lnode *pa,*pb,*pc;pa=(*listA)->next;pb=(*listB)->next;pc=(*listA);while(pa&&pb){if(pa->data.exp==pb->data.exp) {Lnode *waitInsert=pa;pa->data.coe+=pb->data.coe; //系数相加if(pa->data.coe==0) { //系数和为零pa=pa->next;free(waitInsert); //释放系数和为零的结点} else {pa=pa->next;//表尾加⼊新结点，并更新为该新结点pc->next=waitInsert;pc=pc->next;}Lnode *needDelete=pb;pb=pb->next;free(needDelete); //释放listB中的结点} else if(pa->data.exp<pb->data.exp) {Lnode *waitInsert=pa;pa=pa->next;//表尾加⼊新结点，并更新为该新结点pc->next=waitInsert;pc=pc->next;} else {Lnode *waitInsert=pb;pb=pb->next;//表尾加⼊新结点，并更新为该新结点pc->next=waitInsert;pc=pc->next;}}//连接剩余结点if(pa) { //表listA长于listBpc->next=pa;} else {pc->next=pb;}//释放list_B表头free(*listB);return OK;}int main(void){//产⽣多项式相关数据，A(x)、B(x)的项按幂增排列ElemType waitInserted_A[] = {{ 7, 0 },{ 3, 1 },{ 9, 8 },{ 5,17 },{ 2, 20 }};ElemType waitInserted_B[] = {{ 8, 1 },{ 22, 7 },{ -9, 8 },{ -4, 17 }};//获得数组长度int arrLength_A=sizeof(waitInserted_A)/sizeof(waitInserted_A[0]); int arrLength_B=sizeof(waitInserted_B)/sizeof(waitInserted_B[0]);//头插法建⽴链表list_A和list_B分别保存A(x)、B(x)两个多项式的数据 LinkList list_A,list_B;InitList(&list_A);InitList(&list_B);CreateList_H(&list_A,waitInserted_A,arrLength_A);CreateList_H(&list_B,waitInserted_B,arrLength_B);printf("多项式A(x)的数据：\n");ListTraverse(list_A); //遍历测试printf("多项式B(x)的数据：\n");ListTraverse(list_B); //遍历测试//计算Y(x)=A(x)+B(x)；结果数据放⼊list_A;GetPolynthicSum(&list_A,&list_B);printf("多项式Y(x)=A(x)+B(x)的数据：\n");ListTraverse(list_A); //遍历测试printf("\nEND!");return0; }。

数据结构单链表实验报告一、实验目的本次实验的主要目的是深入理解和掌握数据结构中的单链表概念、原理和操作方法，通过实际编程实现单链表的创建、插入、删除、查找等基本操作，提高对数据结构的实际应用能力和编程技能。

二、实验环境本次实验使用的编程语言为C+＋，编程工具为Visual Studio 2019。

三、实验原理单链表是一种常见的数据结构，它由一系列节点组成，每个节点包含数据域和指针域。

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

单链表的优点是可以动态地分配内存，灵活地插入和删除节点，但其缺点是访问特定位置的节点需要从头开始遍历，时间复杂度较高。

四、实验内容（一）单链表的创建创建单链表的基本思路是依次创建节点，并将节点通过指针链接起来。

以下是创建单链表的代码实现：｀｀｀cppinclude ＜iostream>using namespace std;／／定义链表节点结构体struct ListNode ｛int data;ListNode next;ListNode(int x) ： data(x)， next(NULL) ｛｝｝；／／创建单链表ListNode createList(）｛int num, value;cout ＜＜＂请输入节点个数: ＂；cin ＞＞ num;ListNode head ＝ NULL;ListNode tail ＝ NULL;for （int i ＝ 0; i ＜ num; i+＋）｛cout ＜＜＂请输入第＂＜＜ i ＋ 1 ＜＜＂个节点的值: ＂；cin ＞＞ value;if （head ＝＝ NULL) ｛head ＝ newNode;tail ＝ newNode;｝ else ｛tail>next ＝ newNode;tail ＝ newNode;｝｝return head;｝｀｀｀（二）单链表的插入操作单链表的插入操作可以分为在表头插入、在表尾插入和在指定位置插入。

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

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

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

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. 单链表的删除单链表的删除可以分为在链表头部删除、在链表尾部删除和在链表中间删除三种情况。

《数据结构》课程实验教学手册姓名：王俊东学号：1101120216专业：计算机科学与技术班级：2012 级 2 班任课教师：王爽时间：2013-2014 年度第1 学期综合成绩：许昌学院计算机科学与技术学院《数据结构》课程实验教学手册计算机科学与技术学院《数据结构》课程组实验手册使用及要求实验操作是教学过程中理论联系实际的重要环节，而实验报告的撰写又是知识系统化的吸收和升华过程，因此，实验报告应该体现完整性、规范性、正确性、有效性。

现将实验报告撰写的有关内容说明如下：1、实验预习报告必须在实验前完成。

2、实验时带好实验手册方可进行实验。

3、实验时按实验预习报告内容进行实验。

并如实填写实验过程及实验小结。

4、实验结束后填写通过后的源程序。

通过后的源程序可以手写也可以打印粘贴。

实验情况一览表实验一实验名称顺序表及其应用实验性质验证性实验学时数2学时printf("请选择正确的操作！\n");break;}}while(choice!=0);printf("谢谢使用!\n");return 0;}四实验小结初步了解线性表的顺序存储结构，及其定义格式。

掌握在顺序表上进行插入、删除等操作的算法。

但在顺序表的操作上不是十分熟练。

五成绩实验二实验名称单链表及其应用实验性质综合性实验学时数4学时四实验小结初步了解线性表的链式存储结构，及其定义格式。

掌握了在链表上进行插入、删除等操作的算法。

对链表的了解不是很深入，在其使用上往往会犯一些错误比如在链表中进行插入插不到指定位置，删除时位置错误等。

五成绩实验三实验名称线性表综合练习实验性质设计性实验学时数6学时四实验小结对链式表有了进一步的了解，能够利用链式表解决一些实际问题。

了解了链式表的优势，他不会造成空间的浪费，对于插入和删除操作上链式表比顺序表有明显的优势。

五成绩实验四实验名称栈和队列及其应用实验性质设计性实验学时数4学时四实验总结对栈和队列有了初步的了解，他们都是一种特殊的操作受限制线性表，栈的特点是先进后出而队列的是先进先出。

单链表应⽤实例及代码实现问题：使⽤带 head 头的单向链表实现 –英雄列表管理完成对英雄⼈物的增删改查操作。

⾸先准备⼀个hero类：1. class hero {2. private int num;//序号(排名)3. private String name;//名称4. private String nikname;//别名5. private hero next;//指向下⼀个6.7. public hero(int num, String name, String nikname) { ... } //构造器8.9. public int getNum() { ... }10. public void setNum(int num) { ... }11. public String getName() { ... }12. public void setName(String name) { ... }13. public String getNikname() { ... }14. public void setNikname(String nikname) { ... }15. public hero getNext() { ... }16. public void setNext(hero next) { ... }17.18. @Override19. public String toString() { ... } //为了显⽰⽅便显⽰重写tostring20. }1) 第⼀种⽅法：在添加英雄时，直接添加到链表的尾部（add（））思路分析： 添加（创建） 1、先创建⼀个head头节点（①不存放具体数据，②作⽤就是表⽰单链表头next）private hero head = new hero(-1, "", ""); //先初始化⼀个头节点，头节点不能动，不存放具体数据 2、之后我们每添加⼀个节点，就直接加⼊到链表的最后 遍历 1、通过⼀个辅助变量遍历，帮助遍历整个链表2) 第⼆种⽅式在添加英雄时，根据排名将英雄插⼊到指定位置(如果有这个排名，则添加失败，并给出提⽰) 思路分析： 1、⾸先找到新添加的节点的位置，是通过辅助变量，通过遍历来搞定 2、新的节点.next=temp.next （temp为插⼊后的新节点的前⼀个节点） 3、将temp.next=新的节点3) 修改节点 思路分析： 1、先找到该节点，通过遍历 2、 = ; temp.nickname= newHero.nickname；4) 删除节点（delete（）） 思路分析： 1、先找到需要删除的这个节点的前⼀个节点temp 2、 temp.next=temp.next.next 3、删除的节点，将不会有其他引⽤，会被GC掉单链表代码实现：1. public class singlelinkedlist {2. //先初始化⼀个头节点，头节点不能动，不存放具体数据3. private hero head = new hero(-1, "", "");4.5. //添加节点到单向链表6. /**7. * 思路：当不考虑标编号顺序时8. * 1、找到当前链表的最后节点9. * 2、将最后这个节点的next指向新的节点10. */11. public void add(hero h) {12. //因为head节点不能动，因此我们需要⼀个辅助变量temp13. hero temp = head;14. //遍历链表，找到最后⼀个节点15. while (true) {16. if (temp.getNext() == null) {17. break;19. //如果没有到最后，将temp后移20. temp = temp.getNext();21. }22. //当退出while循环时，temp就指向了链表的最后23. //将最后这个节点的next指向新的节点24. temp.setNext(h);25. }26.27. //第⼆种⽅式在添加英雄时，根据排名将英雄插⼊到指定位置28. //(如果有这个排名，则添加失败，并给出提⽰)29. public void addByOrder(hero h) {30. //因为头节点不能动，因此我们仍然通过⼀个辅助指针(变量)来帮助找到添加的位置31. //因为单链表，因为我们找的temp是位于添加位置的前⼀个节点，否则插⼊不了32. hero temp = head;33. boolean flag = false;// flag 标志添加的编号是否存在，默认为 false34. while (true) {35. if (temp.getNext() == null) {//说明 temp 已经在链表的最后36. break;37. } else if (temp.getNext().getNum() > h.getNum()) {//位置找到，就在 temp 的后⾯插⼊38. break;39. } else if (temp.getNext().getNum() == h.getNum()) {//说明希望添加的 heroNode 的编号已然存在40. flag = true;41. break;42. }43. temp = temp.getNext();//后移，遍历当前链表44. }45. if (flag) { //不能添加，说明编号存在46. System.out.println("添加的序号为" + h.getNum() + "的英雄序号已经存在，添加失败。

学生成绩管理以单链表作为存储结构，设计和实现某班某门课程成绩管理的完整程序。

程序要求完成如下功能：（1）创建成绩链表，学生数据包含学生的学号、姓名和成绩。

（2）可以在指定学号学生前插入学生成绩数据。

（3）可以删除指定学号的学生数据。

（4）可以计算学生的总数。

（5）可以按学号和姓名查找学生。

（6）可以显示所有学生的成绩。

（7）可以把学生成绩按从高到低的顺序排列。

此处的设计思想基本与顺序表相同，只是对保存学生成绩的线性表采用不同的存储结构实现。

本例中用到的学生数据也是程序运行时由用户从键盘输入，保存到一个单链表中。

学生结构体类型的定义与顺序表应用举例处的定义相同，用Ｃ语言描述如下：typedef struct Student /*学生类型定义*/{ int score; /*成绩*/char sno[5],sname[8]; /*学号,姓名*/}Student;当学生的学号为“#”时，也是表示数据输入的结束。

单链表中保存的数据元素均为学生Student类型，则单链表定义如下：typedef struct Node /*结点类型定义*/{ Student studentInfo; /*学生信息*/struct Node *next; /*指向后继元素的指针域*/}LinkList;对学生的成绩按从高到低排序时，使用的也是直接插入排序思想。

此外，为了排序后还能在原单链表上继续进行操作，这里是把单链表中的内容复制到一个新单链表中，对新单链表排序，原单链表不变。

下面是以单链表作为存储结构实现的学生某门课程成绩管理的完整Ｃ语言程序。

#include<string.h>#include<malloc.h>#include <stdlib.h>#include <stdio.h>typedef struct Student /*学生类型定义*/{ int score; /*成绩*/char sno[5],sname[8]; /*学号,姓名*/}Student;typedef struct Node /*结点类型定义*/{ Student studentInfo; /*学生信息*/struct Node *next; /*指向后继元素的指针域*/}LinkList;void display(LinkList *p) /*在屏幕上显示一个学生的成绩信息*/{ printf("\n\n\nno\t\tname\t\tscore: ");printf("\n%s",p->studentInfo.sno); /*打印学号*/printf("\t\t ");printf("%s",p->studentInfo.sname); /*打印姓名*/printf("\t\t ");printf("%-4d\n",p->studentInfo.score); /*打印成绩*/}void displayAll(LinkList *L) /*在屏幕上显示所有学生的成绩信息*/ { LinkList *p;p=L->next;printf("\n\n\nno\t\tname\t\tscore: ");while(p){ printf("\n%s",p->studentInfo.sno); /*打印学号*/printf("\t\t ");printf("%s",p->studentInfo.sname); /*打印姓名*/printf("\t\t ");printf("%-4d\n",p->studentInfo.score);/*打印成绩*/p=p->next;}}LinkList *inputdata( ) /*输入学生信息*/{ LinkList *s=NULL ; /*s是指向新建结点的指针*/ char sno[5]; /*存储学号的数组*/printf("\n ");printf(" no: ");scanf("%s",sno); /*输入学号*/if(sno[0]=='#') /*#结束输入*/return s;s=( LinkList *)malloc(sizeof(LinkList));strcpy(s->studentInfo.sno,sno);if(strlen(sno)>4) /*如果sno字符个数大于等于5，因为字符串没有'\0'结束标志，在读数据时将把姓名字符一起读到sno数组，因此做了如下处理*/ s->studentInfo.sno[4]='\0';printf(" name: ");scanf("%s",s->studentInfo.sname); /*输入姓名*/printf("score: ");scanf("%d",&s->studentInfo.score);/*输入成绩*/return s;}LinkList *createTailList( ) /*以尾插法建立带头结点的学生信息单链表*/{ LinkList *L,*s, *r; /*L头指针，r尾指针，s是指向新建结点的指针*/ L=( LinkList *)malloc(sizeof (LinkList)); /*建立头结点，申请结点存储空间*/r=L; /*尾指针指向头结点*/printf("\请输入学生成绩，当学号no为\"#\"时结束：\n\n ");while (1) /*逐个输入学生的成绩*/{ s=inputdata( );if(!s) break; /*s为空时结束输入*/r->next=s; /*把新结点插入到尾指针后*/r=s; /*r 指向新的尾结点*/ }r->next=NULL; /*尾指针的指针域为空*/displayAll(L); /*显示所有学生信息*/return L;}Void locateElemByno(LinkList *L, char ch[5]) /*按学号查找学生的算法*/{ LinkList *p=L->next; /*从第一个结点开始查找*/ while ( p && (strcmp(p->studentInfo.sno,ch)!=0))/*p不空且输入学号与链表中学号不等*/ p = p ->next;if (!p){ printf("\n\n\tDon't find the student!\n" );}else{ display(p); /*显示查找到的学生信息*/}}void locateElemByname(LinkList *L, char sname[8])/*按姓名查找学生的算法*/{ LinkList *p=L->next; /*从第一个结点开始查找*/ while ( p&& (strcmp(p->studentInfo.sname,sname)!=0)) /*p不空且输入姓名与链表中姓名不等*/ p = p ->next;if (!p){ printf("\n\n\tDon't find the student!\n" ); }else{display(p); /*显示查找到的学生信息*/}}int lengthList (LinkList *L) /*求学生总人数的算法*/{ LinkList * p=L->next; /* p指向第一个结点*/int j=0;while (p){ p=p->next; j++ ;} /* p所指的是第j 个结点*/return j;}void insertElem ( LinkList *L, char ch[5]) /*在带头结点的单链表L中指定学号前插入学生*/ { LinkList *p,*s;p=L; /*从头结点开始查找学号为ch的结点的前趋结点p */while ((p->next) && (strcmp(p->next->studentInfo.sno,ch)!=0))p = p ->next;s=inputdata(); /*输入欲插入学生信息*/s->next=p->next;p->next=s;}void deleteElem (LinkList *L, char ch[5]) /*删除给定学号的学生信息的算法*/{ LinkList *p,*q;p=L;while ( (p->next)&&(strcmp(p->next->studentInfo.sno,ch)!=0 )){ p=p->next; /*从头结点开始查找学号为ch的结点的前趋结点p*/}if (!p->next) /* 已经扫描到表尾也没找到*/{ printf("\n\n\tDon't find the student!\n" );}else{ q=p->next; /*q指向学号为ch的结点*/printf("\n\ndeleted student's information:");display(q);p->next=q->next; /*改变指针*/free(q); /*释放q占用空间*/printf("\n\nall student's information :");displayAll(L);}}void insertSort(LinkList *L) /*用直接插入排序思想把学生的成绩按从高到低排序，结果保存在新有序链表中，原链表不变*/{ L inkList *L1,*p; /*L1有序链表的表头，p插入位置前结点*/ LinkList *q,*s; /*q欲插入L1中的结点*/int len;len=lengthList (L) ;L1=( LinkList *)malloc(sizeof (LinkList)); /*建立头结点，申请结点存储空间*/if (L->next) /*链表L非空*/{ /*生成有序链表的第一个结点*/s=( LinkList *)malloc(sizeof (LinkList)); /*建立结点，申请结点存储空间*/strcpy(s->studentInfo .sno ,L->next->studentInfo.sno);strcpy(s->studentInfo .sname,L->next->studentInfo.sname);s->studentInfo .score =L->next->studentInfo.score;s->next =NULL;L1->next=s; /*只有原单链表的第一个结点的有序链表L1*/q=L->next->next; /*原单链表的第二个结点，q即要插入有序链表L1中的结点*/ }else{ printf("\nthe student link list is empty\n");return;}while(q) /*链表L中有结点*/{ p=L1 ; /*从链表L1的第一个结点开始比较*/while((p->next) && (p->next->studentInfo.score>=q->studentInfo.score))p=p->next ; /*查找插入位置前结点*//*生成欲插入有序链表中的结点*/s=( LinkList *)malloc(sizeof (LinkList));/*建立结点，申请结点存储空间*/strcpy(s->studentInfo .sno ,q->studentInfo.sno);strcpy(s->studentInfo .sname ,q->studentInfo.sname);s->studentInfo .score =q->studentInfo.score;if(!p->next) /*p是有序链表的最后一个结点*/{ s->next =NULL ;p->next =s;}else{ s->next =p->next ;p->next =s;}q=q->next; /*下一个欲插入有序链表的结点*/ }/*while(!q)*/displayAll(L1); /*显示生成的有序链表*/}void main(){ printf("=============================================\n\n");printf(" 带头结点的学生成绩管理程序\n\n");printf("=============================================\n\n");LinkList *L;char ch[5],sname[8];int b=1;while(b){ int a;printf("\n\n");printf(" <1>创建（带头尾插）<2>指定学号前插入<3>按学号删除\n ");printf("<4>计算学生总数<5> 按学号查找<6> 按姓名查找\n");printf(" <7>显示所有学生<8>成绩排序<9> 退出\n");printf("\n请输入功能选项：");scanf("%d",&a);switch(a){case 1:L=CreateTailList();break;case 2:printf("\n输入欲在哪个学号前插入数据:");scanf("%s",ch);insertElem(L, ch) ;break;case 3:printf("\n输入欲删除学生的学号:");scanf("%s",ch);deleteElem(L, ch) ;break;case 4:printf(" \n学生总数为：%d \n",lengthList (L) );break;case 5:printf("\n输入欲查找学生的学号:");scanf("%s",ch);locateElemByno(L, ch) ;break;case 6:printf("\n输入欲查找学生的姓名:");scanf("%s",sname);locateElemByname(L, sname );break;case 7:displayAll(L);break;case 8:insertSort(L);break;case 9:printf("\n已退出\n");b=0;break;};}}上机运行程序后，程序执行结果如图2.31（ａ）～（ｉ）所示。

js链表的应用场景
JavaScript链表可以用来实现多种功能和应用场景，以下是其中几个常见的应用场景：
1. 前端数据结构：链表通常用于构建复杂数据结构，例如树、堆和图等。

在前端开发中，链表可以用于构建递归结构，例如React中的Virtual DOM就是基于链表实现的。

此外，链表还可以用于构建消息队列、循环列表、哈希表等。

2. 数据库：链表可用于实现数据库中的索引结构。

一些数据库系统，如Oracle 和Microsoft SQL Server等，使用B树和B+树实现索引结构，这些树是由一个个链表节点组成的。

3. 算法与排序：链表是一种基础性的数据结构，常用于算法题目中。

链表可以用来实现堆排序、归并排序、快速排序等高效排序算法。

4. Web应用：链表可以用于实现前端路由跳转机制，例如React-Router就是基于链表实现的。

此外，链表还可以用于构建无限滚动页面、响应式布局等。

5. 游戏编程：链表可以用来存储游戏中的实体对象、事件处理器等。

例如在Unity3D中，链表可用于管理游戏对象、命令对象等。

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

基本操作包括以下几种：
1. 创建链表：创建一个空链表，即创建一个头节点。

2. 插入节点：在链表的任意位置插入一个节点。

- 头部插入：将新节点作为新的头节点，其指针指向原头节点。

- 中间插入：将新节点插入到指定位置的节点之前，其指针指向指定位置的节点。

- 尾部插入：找到链表尾部节点，将新节点插到尾部节点的后面。

3. 删除节点：在链表中删除指定节点。

- 头部删除：将头节点删除，将头节点的下一个节点作为新的头节点。

- 中间删除：找到指定节点的前驱节点，将前驱节点的指针指向指定节点的后继节点。

- 尾部删除：找到尾部节点的前驱节点，将前驱节点的指针设为NULL。

4. 查找节点：在链表中查找指定数据的节点。

- 遍历链表，逐个比较节点的数据元素，直到找到指定数据或遍历到末尾节点。

5. 修改节点：在链表中修改指定节点的数据。

- 遍历链表，找到指定节点，修改其数据元素。

6. 遍历链表：按顺序遍历链表中的所有节点，进行相应操作。

这些是单链表的基本操作，可以根据需求进行组合和扩展。