链表 实例

mfc编程cstringlist实例MFC编程中的CStringList实例在MFC（Microsoft Foundation Classes）编程中，CStringList是一个非常有用的类，用于管理字符串的链表。

它提供了许多方便的功能，使得操作字符串链表变得更加简单和高效。

在本文中，我们将逐步回答关于CStringList的问题，并给出一些实例代码来帮助读者更好地理解和使用这个类。

问题1：什么是CStringList？CStringList是MFC框架中的一个类，它是一个模板类，用于处理字符串的链表。

它使用的是C++的模板机制，可以在链表中存储任意类型的数据。

但在这里，我们主要关注它在处理字符串方面的应用。

问题2：如何创建一个CStringList对象？要创建一个CStringList对象，只需简单地声明一个新的实例即可：CStringList strList;这将创建一个名为strList的CStringList对象。

您可以根据需要创建多个实例，并在程序的任何地方使用它们。

问题3：如何向CStringList中添加字符串？要向CStringList中添加字符串，可以使用AddHead()或AddTail()成员函数。

AddHead()函数将字符串添加到链表的头部，而AddTail()函数则将字符串添加到链表的尾部。

下面是一些示例代码：CStringList strList;strList.AddHead("Hello");strList.AddTail("World");这将创建一个名为strList的CStringList对象，并向其头部添加字符串"Hello"，在其尾部添加字符串"World"。

问题4：如何遍历并访问CStringList中的字符串？要遍历并访问CStringList中的字符串，可以使用CstringList的一个迭代器。

[转载整理]C语⾔链表实例 C语⾔链表有单链表、双向链表、循环链表。

单链表由数据域和指针域组成，数据域存放数据，指针域存放该数据类型的指针便于找到下⼀个节点。

双链表则含有头指针域、数据域和尾指针域，域单链表不同，双链表可以从后⼀个节点找到前⼀个节点，⼆单链表则不⾏。

循环链表就是在单链表的基础上，将头结点的地址指针存放在最后⼀个节点的指针域⾥以，此形成循环。

此外还有双向循环链表，它同时具有双向链表和循环链表的功能。

单链表如：链表节点的数据结构定义struct node{int num;struct node *p;} ;在此链表节点的定义中，除⼀个整型的成员外，成员p是指向与节点类型完全相同的指针。

※在链表节点的数据结构中，⾮常特殊的⼀点就是结构体内的指针域的数据类型使⽤了未定义成功的数据类型。

这是在C中唯⼀规定可以先使⽤后定义的数据结构。

链表实例代码：1// 原⽂地址 /wireless-dragon/p/5170565.html2 #include<stdio.h>3 #include<stdlib.h>4 #include<string.h>56 typedef int elemType;//定义存⼊的数据的类型可以是int char78 typedef struct NODE{ //定义链表的结构类型9 elemType element;10struct NODE *next;11 }Node;1213/************************************************************************/14/* 以下是关于线性表链接存储（单链表）操作的19种算法 */1516/* 1.初始化线性表，即置单链表的表头指针为空 */17/* 2.创建线性表，此函数输⼊负数终⽌读取数据*/18/* 3.打印链表，链表的遍历*/19/* 4.清除线性表L中的所有元素，即释放单链表L中所有的结点，使之成为⼀个空表 */20/* 5.返回单链表的长度 */21/* 6.检查单链表是否为空，若为空则返回１，否则返回０ */22/* 7.返回单链表中第pos个结点中的元素，若pos超出范围，则停⽌程序运⾏ */23/* 8.从单链表中查找具有给定值x的第⼀个元素，若查找成功则返回该结点data域的存储地址，否则返回NULL */24/* 9.把单链表中第pos个结点的值修改为x的值，若修改成功返回１，否则返回０ */25/* 10.向单链表的表头插⼊⼀个元素 */26/* 11.向单链表的末尾添加⼀个元素 */27/* 12.向单链表中第pos个结点位置插⼊元素为x的结点，若插⼊成功返回１，否则返回０ */28/* 13.向有序单链表中插⼊元素x结点，使得插⼊后仍然有序 */29/* 14.从单链表中删除表头结点，并把该结点的值返回，若删除失败则停⽌程序运⾏ */30/* 15.从单链表中删除表尾结点并返回它的值，若删除失败则停⽌程序运⾏ */31/* 16.从单链表中删除第pos个结点并返回它的值，若删除失败则停⽌程序运⾏ */32/* 17.从单链表中删除值为x的第⼀个结点，若删除成功则返回1,否则返回0 */33/* 18.交换2个元素的位置 */34/* 19.将线性表进⾏冒排序 */35363738/*注意检查分配到的动态内存是否为空*/3940414243/* 1.初始化线性表，即置单链表的表头指针为空 */44void initList(Node **pNode)45 {46 *pNode=NULL;47 printf("initList函数执⾏，初始化成功\n");48 }4950/* 2.创建线性表，此函数输⼊负数终⽌读取数据*/51 Node *creatList(Node *pHead)52 {53 Node *p1,*p2;54 p1=p2=(Node *)malloc(sizeof(Node));55if(p1 == NULL || p2 ==NULL)57 printf("内存分配失败\n");58 exit(0);59 }60 memset(p1,0,sizeof(Node));6162 scanf("%d",&p1->element);63 p1->next=NULL;6465while(p1->element >0) //输⼊的值⼤于0则继续，否则停⽌66 {67if(pHead == NULL)//空表，接⼊表头68 {69 pHead=p1;70 }71else72 {73 p2->next=p1;74 }7576 p2=p1;77 p1=(Node *)malloc(sizeof(Node));7879if(p1==NULL||p2==NULL)80 {81 printf("内存分配失败\n");82 exit(0);83 }84 memset(p1,0,sizeof(Node));85 scanf("%d",&p1->element);86 p1->next=NULL;87 }88 printf("CreatList函数执⾏，链表创建成功\n");89return pHead;90 }9192/* 3.打印链表，链表的遍历*/93void printList(Node *pHead)94 {95if(NULL==pHead)96 {97 printf("PrintList函数执⾏，链表为空\n");98 }99else100 {101while(NULL!=pHead)102 {103 printf("%d\n",pHead->element);104 pHead=pHead->next;105 }106 }107108 }109110111/* 4.清除线性表L中的所有元素，即释放单链表L中所有的结点，使之成为⼀个空表 */ 112void clearList(Node *pHead)113 {114 Node *pNext;115116if(pHead==NULL)117 {118 printf("clearList函数执⾏，链表为空\n");119return;120 }121while(pHead->next!=NULL)122 {123 pNext=pHead->next;124free(pHead);125 pHead=pNext;126 }127 printf("clearList函数执⾏，链表已经清除！\n");128129 }130131/* 5.返回链表的长度*/132int sizeList(Node *pHead)133 {134int size=0;135136while(pHead!=NULL)137 {138 size++;139 pHead=pHead->next;141 printf("sizelist函数执⾏，链表长度为%d\n",size);142return size;143 }144145/* 6.检查单链表是否为空，若为空则返回１，否则返回０ */146int isEmptyList(Node *pHead)147 {148if(pHead==NULL)149 {150 printf("isEmptylist函数执⾏，链表为空！\n");151return1;152 }153154else155 printf("isEmptylist函数执⾏，链表⾮空！\n");156return0;157158 }159160/* 7.返回链表中第post节点的数据，若post超出范围，则停⽌程序运⾏*/161int getElement(Node *pHead,int pos)162 {163int i=0;164if(pos<1)165 {166 printf("getElement函数执⾏，pos值⾮法！");167return0;168 }169if(pHead==NULL)170 {171 printf("getElement函数执⾏，链表为空！");172 }173174while (pHead!=NULL)175 {176 ++i;177if(i==pos)178 {179break;180 }181 pHead=pHead->next;182 }183if(i<pos)184 {185 printf("getElement函数执⾏，pos值超出链表长度\n");186return0;187 }188 printf("getElement函数执⾏，位置%d中的元素为%d\n",pos,pHead->element);189190return1;191 }192193//8.从单⼀链表中查找具有给定值x的第⼀个元素，若查找成功后，返回该节点data域的存储位置，否则返回NULL 194 elemType *getElemAddr(Node *pHead,elemType x)195 {196if(NULL==pHead)197 {198 printf("getEleAddr函数执⾏，链表为空");199return NULL;200 }201if(x<0)202 {203 printf("getEleAddr函数执⾏，给定值x不合法\n");204return NULL;205 }206while((pHead->element!=x)&&(NULL!=pHead->next))//判断链表是否为空，并且是否存在所查找的元素207 {208 pHead=pHead->next;209 }210if(pHead->element!=x)211 {212 printf("getElemAddr函数执⾏，在链表中没有找到x值\n");213return NULL;214 }215else216 {217 printf("getElemAddr函数执⾏，元素%d的地址为0x%x\n",x,&(pHead->element));218 }219return &(pHead->element);220221 }222223224/*9.修改链表中第pos个点X的值，如果修改成功，则返回1,否则返回0*/225int modifyElem(Node *pNode,int pos,elemType x)226 {227 Node *pHead;228 pHead=pNode;229int i=0;230if(NULL==pHead)231 {232 printf("modifyElem函数执⾏，链表为空\n");233return0;234 }235236if(pos<1)237 {238 printf("modifyElem函数执⾏，pos值⾮法\n");239return0;240 }241242while(pHead!= NULL)243 {244 ++i;245if(i==pos)246 {247break;248 }249 pHead=pHead->next;250 }251252if(i<pos)253 {254 printf("modifyElem函数执⾏，pos值超出链表长度\n");255return0;256 }257 pNode=pHead;258 pNode->element=x;259 printf("modifyElem函数执⾏,修改第%d点的元素为%d\n",pos,x);260261return1;262263 }264265/* 10.向单链表的表头插⼊⼀个元素 */266int insertHeadList(Node **pNode,elemType insertElem)267 {268 Node *pInsert;269 pInsert=(Node *)malloc(sizeof(Node));270if(pInsert==NULL) exit(1);271 memset(pInsert,0,sizeof(Node));272 pInsert->element=insertElem;273 pInsert->next=*pNode;274 *pNode=pInsert;275 printf("insertHeadList函数执⾏，向表头插⼊元素%d成功\n",insertElem);276return1;277 }278279/* 11.向单链表的末尾添加⼀个元素 */280int insertLastList(Node *pNode,elemType insertElem)281 {282 Node *pInsert;283 Node *pHead;284 Node *pTmp;285286 pHead=pNode;287 pTmp=pHead;288 pInsert=(Node *)malloc(sizeof(Node));289if(pInsert==NULL) exit(1);290 memset(pInsert,0,sizeof(Node));291 pInsert->element=insertElem;292 pInsert->next=NULL;293while(pHead->next!=NULL)294 {295 pHead=pHead->next;296 }297 pHead->next=pInsert;298 printf("insertLastList函数执⾏，向表尾插⼊元素%d成功!\n",insertElem);299return1;300 }301302/* 12.向单链表中第pos个结点位置插⼊元素为x的结点，若插⼊成功返回１，否则返回０*/ 303int isAddPos(Node *pNode,int pos,elemType x)304 {305 Node *pHead;306 pHead=pNode;307 Node *pTmp;308int i=0;309310if(NULL==pHead)311 {312 printf("AddPos函数执⾏，链表为空\n");313return0;314 }315316if(pos<1)317 {318 printf("AddPos函数执⾏，pos值⾮法\n");319return0;320 }321322while(pHead!=NULL)323 {324 ++i;325if(i==pos)326break;327 pHead=pHead->next;328 }329330if(i<pos)331 {332 printf("AddPos函数执⾏，pos值超出链表长度\n");333return0;334 }335336 pTmp=(Node *)malloc(sizeof(Node));337if(pTmp==NULL) exit(1);338 memset(pTmp,0,sizeof(Node));339 pTmp->next=pHead->next;340 pHead->next=pTmp;341 pTmp->element=x;342343 printf("AddPos函数执⾏成功，向节点%d后插⼊数值%d\n",pos,x); 344return1;345 }346347/* 13.向有序单链表中插⼊元素x结点，使得插⼊后仍然有序 */348int OrrderList(Node *pNode,elemType x)349 {350//注意如果此数值要排到⾏尾要修改本代码351 Node *pHead;352 pHead=pNode;353 Node *pTmp;354355if(NULL==pHead)356 {357 printf("OrrderList函数执⾏，链表为空\n");358return0;359 }360361if(x<1)362 {363 printf("OrrderList函数执⾏，x值⾮法\n");364return0;365 }366367while(pHead!=NULL)368 {369if((pHead->element)>=x)370break;371 pHead=pHead->next;372 }373374375if(pHead==NULL)376 {377 printf("OrrderList函数查找完毕，该函数中没有该值\n");378return0;379 }380381382 pTmp=(Node *)malloc(sizeof(Node));383if(pTmp==NULL) exit(1);384 memset(pTmp,0,sizeof(Node));385 pTmp->next=pHead->next;386 pHead->next=pTmp;387 pTmp->element=x;388389 printf("OrrderList函数成功插⼊数值%d\n",x);390return1;391 }392393/*14.从单链表中删除表头结点，并把该结点的值返回，若删除失败则停⽌程序运⾏*/ 394int DelHeadList(Node **pList)395 {396 Node *pHead;397 pHead=*pList;398if(pHead!=NULL)399 printf("DelHeadList函数执⾏,函数⾸元素为%d删除成功\n",pHead->element); 400else401 {402 printf("DelHeadList函数执⾏,链表为空!");403return0;404 }405 *pList=pHead->next;406return1;407 }408409/* 15.从单链表中删除表尾结点并返回它的值，若删除失败则停⽌程序运⾏ */410int DelLastList(Node *pNode)411 {412 Node *pHead;413 Node *pTmp;414415 pHead=pNode;416while(pHead->next!=NULL)417 {418 pTmp=pHead;419 pHead=pHead->next;420 }421 printf("链表尾删除元素%d成功!\n",pHead->element);422free(pHead);423 pTmp->next=NULL;424return1;425 }426427/* 16.从单链表中删除第pos个结点并返回它的值，若删除失败则停⽌程序运⾏ */ 428int DelPos(Node *pNode,int pos)429 {430 Node *pHead;431 pHead=pNode;432 Node *pTmp;433434int i=0;435436if(NULL==pHead)437 {438 printf("DelPos函数执⾏，链表为空\n");439return0;440 }441442if(pos<1)443 {444 printf("DelPos函数执⾏，pos值⾮法\n");445return0;446 }447448while(pHead!=NULL)449 {450 ++i;451if(i==pos)452break;453 pTmp=pHead;454 pHead=pHead->next;455 }456457if(i<pos)458 {459 printf("DelPos函数执⾏，pos值超出链表长度\n");460return0;461 }462 printf("DelPos函数执⾏成功，节点%d删除数值%d\n",pos,pHead->element); 463 pTmp->next=pHead->next;464free(pHead);465return1;466 }467468/* 17.从单链表中删除值为x的第⼀个结点，若删除成功则返回1,否则返回0 */469int Delx(Node **pNode,int x)470 {471 Node *pHead;472 Node *pTmp;473 pHead=*pNode;474int i=0;475476if(NULL==pHead)477 {478 printf("Delx函数执⾏，链表为空");479return0;480 }481if(x<0)482 {483 printf("Delx函数执⾏，给定值x不合法\n");484return0;485 }486while((pHead->element!=x)&&(NULL!=pHead->next))//判断链表是否为空，并且是否存在所查找的元素487 {488 ++i;489 pTmp=pHead;490 pHead=pHead->next;491 }492if(pHead->element!=x)493 {494 printf("Delx函数执⾏，在链表中没有找到x值\n");495return0;496 }497if((i==0)&&(NULL!=pHead->next))498 {499 printf("Delx函数执⾏，在链表⾸部找到此元素,此元素已经被删除\n");500 *pNode=pHead->next;501free(pHead);502return1;503 }504 printf("Delx函数执⾏，⾸个为%d元素被删除\n",x);505 pTmp->next=pHead->next;506free(pHead);507return1;508 }509510/* 18.交换2个元素的位置 */511int exchange2pos(Node *pNode,int pos1,int pos2)512 {513 Node *pHead;514int *pTmp;515int *pInsert;516int a;517int i=0;518519if(pos1<1||pos2<1)520 {521 printf("DelPos函数执⾏，pos值⾮法\n");522return0;523 }524525 pHead=pNode;526while(pHead!=NULL)527 {528 ++i;529if(i==pos1)530break;531 pHead=pHead->next;532 }533534if(i<pos1)535 {536 printf("DelPos函数执⾏，pos1值超出链表长度\n");537return0;538 }539540 pTmp=&(pHead->element);541 i=0;542 pHead=pNode;543while(pHead!=NULL)544 {545 ++i;546if(i==pos2)547break;548 pHead=pHead->next;549 }550551if(i<pos2)552 {553 printf("DelPos函数执⾏，pos2值超出链表长度\n");554return0;555 }556557 pInsert=&(pHead->element);558 a=*pTmp;559 *pTmp=*pInsert;560 *pInsert=a;561562 printf("DelPos函数执⾏,交换第%d个和第%d个pos点的值\n",pos1,pos2); 563return1;564 }565566int swap(int *p1,int *p2)567 {568int a;569if(*p1>*p2)570 {571 a=*p1;572 *p1=*p2;573 *p2=a;574 }575return0;576 }577578/* 19.将线性表进⾏冒泡排序 */579int Arrange(Node *pNode)580 {581 Node *pHead;582 pHead=pNode;583584int a=0,i,j;585586if(NULL==pHead)587 {588 printf("Arrange函数执⾏，链表为空\n");589return0;590 }591592while(pHead!=NULL)593 {594 ++a;595 pHead=pHead->next;596 }597598 pHead=pNode;599for(i=0;i<a-1;i++)600 {601for(j=1;j<a-i;j++)602 {603 swap(&(pHead->element),&(pHead->next->element));604 pHead=pHead->next;605 }606 pHead=pNode;607 }608 printf("Arrange函数执⾏，链表排序完毕!\n");609return0;610 }611612int main()613 {614 Node *pList=NULL;615int length=0;616617 elemType posElem;618619 initList(&pList);620 printList(pList);621622 pList=creatList(pList);623 printList(pList);624625 sizeList(pList);626 printList(pList);627628 isEmptyList(pList);629630631 posElem=getElement(pList,3);632 printList(pList);633634 getElemAddr(pList,5);635636 modifyElem(pList,4,1);637 printList(pList);638639 insertHeadList(&pList,5);640 printList(pList);641642 insertLastList(pList,10);643 printList(pList);644645 isAddPos(pList,4,5); 646 printList(pList);647648 OrrderList(pList,6);649 printList(pList);650651 DelHeadList(&pList); 652 printList(pList);653654 DelLastList(pList);655 printList(pList);656657 DelPos(pList,5);658 printList(pList);659660 Delx(&pList,5);661 printList(pList);662663 exchange2pos(pList,2,5); 664 printList(pList);665666 Arrange(pList);667 printList(pList);668669 clearList(pList);670return0;671 }。

链表c语言经典例题
链表是计算机科学中的经典数据结构之一，常用于存储和操作动态数据。

以下是一些常见的链表例题，可以帮助理解链表的基本操作和应用。

1. 链表的创建：
- 创建一个空链表。

- 创建一个包含指定节点值的链表。

2. 链表的插入操作：
- 在链表的头部插入一个节点。

- 在链表的尾部插入一个节点。

- 在指定位置插入一个节点。

3. 链表的删除操作：
- 删除链表的头节点。

- 删除链表的尾节点。

- 删除指定数值的节点。

4. 链表的查找操作：
- 查找链表中指定数值的节点。

- 查找链表的中间节点。

5. 链表的逆序操作：
- 反转整个链表。

- 反转链表的前 N 个节点。

- 反转链表的一部分区间内的节点。

6. 链表的合并操作：
- 合并两个有序链表，使其有序。

- 合并 K 个有序链表，使其有序。

7. 链表的环检测：
- 判断链表中是否存在环，若存在，则返回环的起始节点。

8. 链表的拆分操作：
- 将一个链表按照奇偶位置拆分成两个链表。

以上是一些链表的经典例题，通过解答这些例题，可以加深对链表结构和基本操作的理解。

在编写对应的 C 语言代码时，需要注意链表节点的定义、指针的使用以及内存的动态分配和释放等问题。

链表生活中举例子链表是一种常见的数据结构，在生活中也有很多类似的例子可以来解释。

下面是符合要求的十个例子：1. 电线路：电线路可以看作是一条链表，电流从一端流向另一端。

每个电线都连接在一起，形成一个链式结构。

如果其中一个电线断开了，电流就无法顺利流通，就像链表中的节点断开一样。

2. 银行排队取款：在银行排队取款时，每个人按照先后顺序站在一起，形成一个队列。

当某个人取完款后，后面的人依次向前移动一个位置，就像链表中的节点删除和插入操作一样。

3. 图书馆书架：图书馆的书架上摆放着很多书籍，每本书都有自己的位置。

当有新书到达时，会被插入到合适的位置上，就像链表中的节点插入操作一样。

4. 手链：手链由一串串的珠子或者链节组成，每个珠子或链节都连接在一起。

当手链被拉伸时，每个珠子或链节都会依次移动，就像链表中的节点遍历一样。

5. 网络游戏中的队伍：在网络游戏中，玩家可以组队进行战斗。

每个队友按照先后顺序排列，形成一个队伍。

当队伍中有人离开或加入时，队伍的成员顺序会发生变化，就像链表中的节点删除和插入操作一样。

6. 交通信号灯：交通信号灯由红、黄、绿三个灯组成，每个灯都有自己的状态。

当信号灯的状态发生变化时，车辆会根据不同的灯光信号做出相应的动作，就像链表中的节点更新操作一样。

7. 餐厅的等候队列：在繁忙的餐厅，人们会排队等候就餐。

每个人按照先后顺序排列，形成一个等候队列。

当有桌子空出来时，排在队列最前面的人会被叫号，就像链表中的节点删除操作一样。

8. 航班座位预订系统：在航班座位预订系统中，每个座位都有自己的状态（已预订、空闲）。

当有人预订座位或取消预订时，座位的状态会发生变化，就像链表中的节点更新操作一样。

9. 电影院的座位安排：在电影院观影时，每个座位都有自己的位置。

当有人购买电影票时，会选择一个座位坐下，就像链表中的节点插入操作一样。

10. 城市地铁线路：城市地铁线路将不同的地铁站连接在一起，形成一个链式结构。

C语⾔链表实现商品库存管理系统本⽂实例为⼤家分享了C语⾔链表实现商品库存管理系统的具体代码，供⼤家参考，具体内容如下代码：12345678910111213141516171819202122 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54#include <stdio.h>#include <stdlib.h>#include <string.h>//定义⼀个商品结构体typedef struct sp{char no[12]; //商品编号char name[40]; //名称int workload; //库存量struct sp *next; //指向下⼀节点的指针} SP;//函数声明放在这⾥void ListCreate(SP *L, int n); //创建商品链表节点void LIstSearch(SP *L); //查找商品信息void ListModify(SP *L); //修改商品信息void ListInsert(SP *L); //插⼊商品信息void ListDelete(SP *L); //删除商品信息void Input(SP *p, int i); //输⼊商品信息void SumSp(SP *L); //统计商品的库存总量void Sort(SP *L); //对每类商品的库存量进⾏排名void Menu(); //考试报名管理系统的菜单//商品库存管理系统的主函数⼊⼝int main(){int item, n; //item⽤于接收输⼊的命令，n⽤于接收输⼊的商品⼈数 SP *L = NULL; //初始化⼀个头节点L = (SP *)malloc(sizeof(SP)); //为头节点开辟内存空间L->next = NULL; //将头节点的指针域置空do{Menu(); //菜单printf("请输⼊相应的数字，进⾏相应的操作:\n");scanf("%d", &item);55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 system("cls");switch(item){case1:printf("请输⼊您要录⼊的商品数⽬:");scanf("%d", &n);ListCreate(L, n);getchar();printf("\n请按任意键返回主菜单\n");getchar();system("cls");break;case2:LIstSearch(L); //查找商品信息getchar();printf("\n请按任意键返回主菜单\n");getchar();system("cls");break;case3:ListModify(L); //修改商品库存信息getchar();printf("\n请按任意键返回主菜单\n");getchar();system("cls");break;case4:ListDelete(L); //删除商品信息getchar();printf("\n请按任意键返回主菜单\n");getchar();system("cls");break;case5:ListInsert(L); //插⼊商品信息getchar();printf("\n请按任意键返回主菜单\n");getchar();system("cls");break;case6:SumSp(L);getchar();printf("\n请按任意键返回主菜单\n");getchar();system("cls");break;case7:Sort(L);getchar();printf("\n请按任意键返回主菜单\n");getchar();system("cls");break;case0: //退出商品库存管理系统printf("即将退出商品库存管理系统.....");exit(0);default:printf("您输⼊的指令不正确，请重新输⼊"); }printf("\n\n");} while(item);return0;}//创建链表，将新⽣成的节点插⼊到链表的表头void ListCreate(SP *L, int n){int i;for(i = 0; i < n; i++){SP *p;//将新⽣成的节点插⼊到链表中117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 p = NULL;p = (SP *)malloc(sizeof(SP));Input(p, i);p->next = L->next;L->next = p;}printf("录⼊成功！");}//查找商品库存量void LIstSearch(SP *L){char n[40];SP *p = L->next;if(p == NULL)printf("数据为空，⽆法查找！");else{printf("请输⼊您要查找的商品名称:");scanf("%s", n);while(strcmp(p->name, n) != 0){p = p->next;if(p == NULL){printf("没有找到相关信息\n");return;}}printf("%s的库存量为%d\n",p->name,p->workload);}}//修改商品的库存量void ListModify(SP *L){int a;char nam[40];SP *p = L->next;if(p == NULL)printf("数据为空，⽆法修改！");else{printf("请输⼊您修改的商品名称:");scanf("%s",nam);while(strcmp(p->name, nam) != 0){p = p->next;if(p == NULL){printf("没有找到相关信息\n");return;}}printf("请输⼊您修改后的库存量:");scanf("%d",&p->workload);printf("修改成功");}}//删除商品信息void ListDelete(SP *L){char n[40];SP *p = L->next, *pre = L; //定义p指针指向头节点的指向，定义pre指向头节点，pre始终指向p的前驱节点 if(p == NULL)printf("数据为空，⽆法删除！");else{printf("请输⼊您要删除的商品名称:");scanf("%s", n);while(strcmp(p->name, n) != 0)180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 p = pre->next;if(p == NULL){printf("没有找到相关信息，⽆法删除\n"); return;}}pre->next = p->next;free(p);printf("删除成功");}}//插⼊商品库存的相关信息void ListInsert(SP *L){SP *s = NULL; //⽣成⼀个新节点ss = (SP *)malloc(sizeof(SP));printf("请输⼊商品的商品编号:");scanf("%s", s->no);printf("请输⼊商品的名称:");scanf("%s", s->name);printf("请输⼊商品的库存量:");scanf("%d", &s->workload);s->next = L->next;L->next = s;printf("插⼊成功!");}//统计商品的库存总量void SumSp(SP *L){int sum=0;SP *p=L->next;while(p!=NULL){sum+=p->workload;p=p->next;}printf("商品的库存总量为%d\n",sum);}//对每类商品的库存量进⾏排名void Sort(SP *L){SP *p,*q,*tail,*l;tail=NULL;while((L->next->next) != tail){p = L;q = L->next;while(q->next != tail){if((q->workload) > (q->next->workload)){p->next = q->next;q->next = q->next->next;p->next->next = q;q = p->next;}q = q->next;p = p->next;}tail = q;}printf("商品库存量从⼩到⼤结果如下:\n");l=L->next;while(l!=NULL){if(l->next!=NULL){printf("%s(%d)->",l->name,l->workload); l=l->next;242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293{ printf("%s(%d)",l->name,l->workload); l=l->next;}}}//输⼊商品库存的相关信息void Input(SP *p, int i){ printf("请输⼊第%d 个商品的商品编号:", i + 1);scanf("%s", p->no);printf("请输⼊第%d 个商品的名称:", i + 1); scanf("%s", p->name); printf("请输⼊第%d 个商品的库存量:", i + 1); scanf("%d", &p->workload);}//商品库存管理系统的菜单void Menu(){ printf("\n\n"); printf("\t\t\t===================商品库存管理系统======================\n"); printf("\t\t\t* 作者:XXX 班级:XXXXXXXXXXX 学号:XXXXXXXXXX *\n"); printf("\t\t\t* *\n");printf("\t\t\t* 1>. 录⼊商品库存信息 *\n"); printf("\t\t\t* 2>. 查找某个商品的库存量 *\n"); printf("\t\t\t* 3>. 修改某个商品的库存量 *\n");printf("\t\t\t* 4>. 删除某个商品库存相关信息 *\n");printf("\t\t\t* 5>. 插⼊某个商品的相关信息 *\n");printf("\t\t\t* 6>. 统计商品的库存总量 *\n"); printf("\t\t\t* 7>. 对每类商品的库存量排名 *\n"); printf("\t\t\t* 0>. 退出管理系统 *\n"); printf("\t\t\t* 欢迎使⽤本系统!*\n");printf("\t\t\t========================================================\n");printf("\t\t\t 输⼊选项，按回车进⼊选项: \n");}部分运⾏结果截图以上就是本⽂的全部内容，希望对⼤家的学习有所帮助，也希望⼤家多多⽀持。

C#数据结构之单链表（LinkList）实例详解本⽂实例讲述了C#数据结构之单链表(LinkList)实现⽅法。

分享给⼤家供⼤家参考，具体如下：这⾥我们来看下“单链表(LinkList)”。

在上⼀篇《》的最后，我们指出了：顺序表要求开辟⼀组连续的内存空间，⽽且插⼊/删除元素时，为了保证元素的顺序性，必须对后⾯的元素进⾏移动。

如果你的应⽤中需要频繁对元素进⾏插⼊/删除，那么开销会很⼤。

⽽链表结构正好相反，先来看下结构：每个元素⾄少具有⼆个属性：data和next。

data⽤来存放数据，⽽next⽤来指出它后⾯的元素是谁(有点“指针”的意思)。

链表中的元素，通常也称为节点Node，下⾯是泛型版本的Node.csnamespace 线性表{public class Node<T>{private T data;private Node<T> next;public Node(T val, Node<T> p){data = val;next = p;}public Node(Node<T> p){next = p;}public Node(T val){data = val;next = null;}public Node(){data = default(T);next = null;}public T Data{get { return data; }set { data = value; }}public Node<T> Next{get { return next; }set { next = value; }}}}链表在存储上并不要求所有元素按顺序存储，因为⽤节点的next就能找到下⼀个节点，这好象⼀根“⽤珠⼦串成的链⼦”，要找到其中的某⼀颗珠⼦，只要从第⼀颗节点(通常称为Head节点)开始，不断根据next指向找到下⼀个，直到找到需要的节点为⽌。

第二章指针与链表一、静态存贮和动态存贮1、静态存贮程序中的变量一经说明，计算机操作系统就会在内存空间中分配相应的存贮单元，其中变量名是存贮单元的地址，而变量的值是存贮单元的内容，且该存贮单元自始至终都被该变量所占用，直到程序结束。

如果变量是局部变量，那么在它的作用域内，一经说明也占有一定的存贮单元，直到退出其作用域为止。

这样的变量，在程序执行过程中，不能随时使用随时分配存贮空间，也不能在程序执行的过程中，释放这些空间。

也就是说，一旦给这些变量分配存贮空间，无论程序是否还需要使用，它们都要占用一定的存贮空间，以便给用户存贮数据。

我们称具有这样特点的存贮为静态存贮，它所对应的变量称为静态变量。

如字符类型、数组类型、记录类型等。

这类变量的优点是存贮方便，查找容易，可以通过一个简单的公式随机存取表中的任一元素，逻辑关系上相邻的两个元素在物理位置上也是相邻的，很容易找到前趋与后继元素；缺点是在线性表的长度不确定时，必须分配足够大的存储空间，经常浪费了宝贵的存储资源；而线性表的容量一经定义确定后就难以扩充；在插入和删除线性表的元素时，需要移动大量的元素，时间效率也比较差。

2、动态存贮在程序执行过程中，通过向操作系统申请存贮空间或释放存贮空间的命令，达到动态管理计算机的存贮空间，以保证存贮空间的充分利用。

存贮空间可以随时申请、随时释放，这样的存贮方式称为动态存贮，其变量称为动态变量。

指针变量即为动态变量。

动态存储所需要的空间可以是不连续的，这样有利于充分利用零散的小空间。

但缺无法用O（1）的时间实现存取了。

如何用这些零散的空间存储数组这些大规模数据呢？如何表示这些数据之间的逻辑关系呢？为了表示这些物理存储单元之间的逻辑关系，对于每个数据元素来说，除了要存储它本身的信息（数据域data）外，还要存储它的直接后继元素的存储位置（指针域，一般用link 或next 表示）。

我们往往把这两部分信息合在一起称为一个“结点node”。

实验二链表的基本操作链表是一种常用的数据结构，它由一系列节点组成，每个节点包含两部分：数据和指向下一个节点的指针。

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

本文将围绕链表的基本操作展开讲解，并以此为标题展开内容。

一、链表的插入操作链表的插入操作是指在链表中插入一个新的节点。

插入操作可以分为头插法和尾插法。

1. 头插法：将新节点插入链表的头部，即将新节点的指针指向原链表的头节点，再将链表的头指针指向新节点。

这样可以在常数时间内完成插入操作。

2. 尾插法：将新节点插入链表的尾部，即将原链表的尾节点指针指向新节点，再将新节点的指针指向空。

这样也可以在常数时间内完成插入操作。

二、链表的删除操作链表的删除操作是指删除链表中的一个节点。

删除操作可以分为删除指定节点和删除指定数值的节点两种情况。

1. 删除指定节点：找到待删除节点的前一个节点，将其指针指向待删除节点的下一个节点，再释放待删除节点的内存空间。

2. 删除指定数值的节点：遍历链表，找到数值匹配的节点并删除，具体操作与删除指定节点类似。

三、链表的查找操作链表的查找操作是指在链表中寻找某个节点或数值。

链表的查找操作与数组的查找操作不同，需要从头节点开始遍历整个链表。

1. 查找指定节点：遍历链表，逐个比较节点的值，直到找到目标节点或遍历到链表末尾。

2. 查找指定数值的节点：同样遍历链表，逐个比较节点的值，直到找到目标数值或遍历到链表末尾。

四、链表的其他操作除了插入、删除和查找操作外，链表还可以进行其他操作，如获取链表长度、反转链表和合并链表等。

1. 获取链表长度：遍历链表，计数节点的个数，即为链表的长度。

2. 反转链表：遍历链表，将每个节点的指针指向前一个节点，最后将链表的头指针指向原链表的尾节点。

3. 合并链表：将两个有序链表合并成一个新的有序链表。

遍历两个链表，逐个比较节点的值，将较小值的节点插入新链表中，直到其中一个链表遍历完毕，然后将另一个链表的剩余部分直接插入新链表的尾部。