c语言链表解析
c语言超时重发机制的链表
c语言超时重发机制的链表C语言超时重发机制的链表在网络通信中,超时重发机制是一种常用的技术手段,用于确保数据的可靠传输。
而链表则是一种常见的数据结构,用于存储和管理数据。
本文将结合这两个概念,介绍如何使用链表实现C语言中的超时重发机制。
一、超时重发机制的概念超时重发机制是指在网络通信中,发送方发送数据后,如果在一定时间内未收到接收方的确认信息,发送方会将数据进行重发,以确保数据的可靠传输。
这一机制在保证数据可靠性的同时,也会带来一定的延迟和网络负载。
二、链表的概念及实现链表是一种动态数据结构,由一系列节点组成,每个节点包含数据和指向下一个节点的指针。
链表的优点是可以动态地插入和删除节点,但缺点是访问节点时需要遍历整个链表。
在C语言中,链表可以使用结构体和指针来实现。
首先定义一个节点结构体,包含数据和指向下一个节点的指针:```typedef struct Node {int data; // 数据struct Node* next; // 指向下一个节点的指针} Node;```接下来,我们可以定义一个链表的结构体,包含指向链表头节点和尾节点的指针:```typedef struct LinkedList {Node* head; // 指向链表头节点的指针Node* tail; // 指向链表尾节点的指针} LinkedList;```初始化链表时,头节点和尾节点都为空:```void initLinkedList(LinkedList* list) {list->head = NULL;list->tail = NULL;}```插入节点时,需要创建一个新节点,并更新链表的头节点和尾节点指针:```void insertNode(LinkedList* list, int data) {Node* newNode = (Node*)malloc(sizeof(Node));newNode->data = data;newNode->next = NULL;if (list->head == NULL) {list->head = newNode;list->tail = newNode;} else {list->tail->next = newNode;list->tail = newNode;}}```三、使用链表实现超时重发机制在超时重发机制中,我们可以使用链表来保存待重发的数据包。
c语言数据结构名词解释
C语言数据结构名词解释摘要本文档旨在解释和介绍C语言中常用的数据结构相关的名词,包括数组、链表、栈、队列和树等。
通过对这些名词的解释,读者可以更好地理解这些数据结构在C语言中的应用和原理。
目录1.[数组](#1-数组)2.[链表](#2-链表)3.[栈](#3-栈)4.[队列](#4-队列)5.[树](#5-树)1.数组数组是一种线性数据结构,用来存储一组相同类型的元素。
在C语言中,数组的大小是固定的,即在定义时需要指定数组的长度。
数组可以通过索引来访问和修改其中的元素,索引从0开始。
2.链表链表是一种动态数据结构,由一系列节点组成,节点包含数据和指向下一个节点的指针。
与数组不同,链表的大小可以动态增长或缩小。
链表分为单向链表和双向链表两种形式,其中双向链表的节点还包含指向前一个节点的指针。
3.栈栈是一种后进先出(L I FO)的数据结构,类似于现实生活中的弹夹。
栈有两个基本操作:入栈(p us h)和出栈(po p)。
入栈将数据添加到栈的顶部,而出栈则将栈顶的数据移除。
4.队列队列是一种先进先出(FI FO)的数据结构,类似于现实生活中的排队。
队列有两个基本操作:入队(en qu eu e)和出队(de qu eu e)。
入队将数据添加到队列的末尾,而出队则将队列开头的数据移除。
5.树树是一种分层的数据结构,由节点和边组成。
每个节点可以有零个或多个子节点,其中一个节点被称为根节点,没有父节点的节点称为叶子节点。
树在实际应用中常用于表示分层结构,如文件系统和组织结构等。
结论本文档对C语言中常用的数据结构名词进行了解释和介绍,包括数组、链表、栈、队列和树等。
通过阅读本文档,读者可以更好地理解这些数据结构在C语言中的应用和原理。
在实际编程中,选择适合的数据结构对于提高程序的效率和减少资源占用非常重要。
c链表库函数
c链表库函数全文共四篇示例,供读者参考第一篇示例:C语言是一种广泛应用于系统编程的高级语言,而链表(Linked List)是C语言中常用的数据结构之一。
在C语言中,链表并不像数组一样有现成的库函数可以直接调用,需要通过自定义函数来实现链表的操作。
为了方便使用链表,不少开发者封装了链表操作的库函数,提供了一些常用的链表操作接口,以供开发者使用。
本文将介绍一些常见的C链表库函数及其用法。
一、链表的概念及基本操作链表是一种线性表的存储结构,由若干节点(Node)组成,每个节点包含数据域和指针域。
数据域用于存放数据,指针域用于指向下一个节点。
链表的最后一个节点指针域为空(NULL),表示链表的末尾。
常见的链表操作包括创建链表、插入节点、删除节点、遍历链表、查找节点等。
下面我们来看看C语言中常用的链表库函数。
二、常见的C链表库函数1. 创建链表在C语言中,创建链表的函数通常包括初始化链表头节点和链表节点的操作。
```#include <stdio.h>#include <stdlib.h>//定义链表节点typedef struct node {int data;struct node* next;} Node;2. 插入节点插入节点是链表操作中的重要操作,可以在链表的任意位置插入新节点。
常见的插入方式包括头部插入和尾部插入。
```//头部插入节点void insertNodeAtHead(Node* head, int data) {Node* newNode = (Node*)malloc(sizeof(Node));newNode->data = data;newNode->next = head->next;head->next = newNode;}以上是常见的C链表库函数,这些函数可以帮助我们更方便地操作链表。
在实际开发中,可以根据需要自定义更多的链表操作函数,以满足具体的需求。
c语言中链表的定义
c语言中链表的定义C语言中链表的定义链表是一种常用的数据结构,它是由一系列节点组成的,每个节点包含一个数据元素和一个指向下一个节点的指针。
链表可以用来存储任意类型的数据,而且它的大小可以动态地增加或减少,非常灵活。
在C语言中,链表的定义通常包括两个部分:节点结构体和链表结构体。
节点结构体定义如下:```typedef struct node {int data; // 数据元素struct node *next; // 指向下一个节点的指针} Node;```这里定义了一个名为Node的结构体,它包含两个成员变量:data和next。
其中,data用来存储节点的数据元素,next用来指向下一个节点的指针。
注意,这里的next是一个指向Node类型的指针,这样才能实现链表的连接。
链表结构体定义如下:```typedef struct list {Node *head; // 指向链表头节点的指针Node *tail; // 指向链表尾节点的指针int size; // 链表的大小} List;```这里定义了一个名为List的结构体,它包含三个成员变量:head、tail和size。
其中,head和tail分别指向链表的头节点和尾节点,size表示链表的大小。
通过这两个结构体的定义,我们就可以创建一个链表了。
下面是一个简单的例子:```int main() {List list = {NULL, NULL, 0}; // 初始化链表Node *node1 = (Node*)malloc(sizeof(Node)); // 创建第一个节点node1->data = 1; // 设置节点的数据元素node1->next = NULL; // 设置节点的指针list.head = node1; // 将节点1设置为链表的头节点list.tail = node1; // 将节点1设置为链表的尾节点list.size++; // 链表大小加1// 创建更多的节点...return 0;}```在这个例子中,我们首先初始化了一个空链表,然后创建了第一个节点,并将它设置为链表的头节点和尾节点。
[转载整理]C语言链表实例
[转载整理]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.检查单链表是否为空,若为空则返回1,否则返回0 */22/* 7.返回单链表中第pos个结点中的元素,若pos超出范围,则停⽌程序运⾏ */23/* 8.从单链表中查找具有给定值x的第⼀个元素,若查找成功则返回该结点data域的存储地址,否则返回NULL */24/* 9.把单链表中第pos个结点的值修改为x的值,若修改成功返回1,否则返回0 */25/* 10.向单链表的表头插⼊⼀个元素 */26/* 11.向单链表的末尾添加⼀个元素 */27/* 12.向单链表中第pos个结点位置插⼊元素为x的结点,若插⼊成功返回1,否则返回0 */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.检查单链表是否为空,若为空则返回1,否则返回0 */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的结点,若插⼊成功返回1,否则返回0*/ 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语言中linklist的作用
c语言中linklist的作用C语言中LinkList的作用什么是LinkListLinkList(链表)是C语言中用来存储和操作数据的一种数据结构。
它与数组相比,拥有更灵活的插入和删除操作。
链表由节点(Node)组成,每个节点包含一个数据项和一个指向下一个节点的指针。
链表的头节点是链表的起始点,尾节点则指向NULL。
LinkList的作用1.动态内存分配:链表的节点可以动态地分配和释放内存,因此链表可以根据实际需要进行动态的添加和删除操作,不受固定大小的限制。
2.插入和删除操作效率高:由于链表的特性,插入和删除操作只需要修改节点指针的指向,而不需要移动其他节点,因此链表在某些特定场景下可以比数组更高效。
3.实现高级数据结构:链表可以用来实现其他高级数据结构,比如栈(Stack)和队列(Queue),或者作为其他数据结构的底层实现。
4.提供灵活的数据结构设计:链表可以设计成单向链表、双向链表或循环链表,根据实际需求选择合适的链表结构。
LinkList的应用场景链表在许多编程问题中都有着广泛的应用,以下是一些常见的应用场景: - 线性表:链表可以实现线性表,可以用来存储和操作一组有序的数据。
- 多项式运算:链表可以用来存储和运算多项式,实现多项式的相加、相乘等操作。
- 图的表示:链表可以用来表示图的连接关系,比如邻接链表表示法。
- 高级数据结构:链表可以作为实现其他高级数据结构的基础,比如树(Tree)、图(Graph)等。
- 文件操作:链表可以用来实现文件的读取和写入操作,链表可以实现文件的增删改查等功能。
总结链表作为一种灵活和高效的数据结构,广泛应用于C语言的编程中。
通过链表,我们可以动态地分配内存,高效地进行插入和删除操作。
而且,链表还可以作为其他高级数据结构的基础实现,扩展了数据结构的功能和应用场景。
在C语言中,掌握链表的使用方法和原理,对于编写高效的程序和解决复杂的编程问题都有很大的帮助。
c语言链表递归逆序输出
c语言链表递归逆序输出链表是数据结构中常用的一种,在C语言中经常会用链表进行数据的存储和操作。
链表是由节点组成,每个节点都有一个指向下一个节点的指针。
在这篇文章中,我们将讨论如何使用递归来逆序输出一个链表。
步骤一:定义链表节点结构体在C语言中定义链表是一种非常常见的操作。
首先我们需要定义节点的结构体。
节点结构体通常包括一个数据域和一个指向下一个节点的指针域。
数据域用来存储节点的数据,指针域则用来表示指向下一个节点的指针。
结构体定义如下:```struct node {int data; // 数据域struct node *next; // 指针域};```步骤二:定义逆序输出函数接下来我们需要定义一个函数来逆序输出链表。
使用递归方法实现链表的逆序输出。
```void reversePrint(struct node *head){if(head == NULL) {return;}if(head->next != NULL){reversePrint(head->next);}printf("%d ", head->data);}```这个递归函数非常简单。
首先我们检查链表头指针是否为空。
如果为空,则返回(因为该链表中没有节点)。
然后我们检查是否有下一个节点。
如果有,则执行函数自身将下一个节点作为参数传递给它。
这样就可以将链表倒序遍历,最后输出节点的数据。
步骤三:测试函数我们可以使用以下代码来测试reversePrint函数:```int main() {struct node *head, *second, *third, *fourth;// 分配空间head = (struct node*)malloc(sizeof(struct node));second = (struct node*)malloc(sizeof(struct node));third = (struct node*)malloc(sizeof(struct node));fourth = (struct node*)malloc(sizeof(struct node));// 赋值head->data = 10;head->next = second;second->data = 20;second->next = third;third->data = 30;third->next = fourth;fourth->data = 40;fourth->next = NULL;// 逆序输出链表printf("链表逆序输出:\n");reversePrint(head);// 释放空间free(head);free(second);free(third);free(fourth);return 0;}```这里我们创建一个包含四个节点的链表,然后将该链表传递给我们刚刚定义的reversePrint函数。
c语言中linklist类型
c语言中linklist类型LinkList类型是C语言中常用的数据结构之一,用于表示链表。
链表是一种动态数据结构,它可以根据需要动态地分配和释放内存空间,比较灵活。
在本文中,我们将深入探讨LinkList类型及其相关操作。
一、什么是链表链表是一种由节点组成的数据结构,每个节点包含数据和指向下一个节点的指针。
链表中的节点可以按照任意顺序存储,通过指针将它们连接起来。
与数组相比,链表的插入和删除操作更加高效,但是访问元素的效率较低。
链表分为单向链表和双向链表两种形式,本文主要介绍单向链表。
二、LinkList类型的定义在C语言中,我们通过结构体来定义链表节点的数据结构,具体定义如下:```ctypedef struct Node{int data;struct Node *next;}Node;typedef Node *LinkList;```其中,Node表示链表的节点类型,LinkList表示链表的类型。
三、LinkList类型的常用操作1. 初始化链表初始化链表主要是将链表的头指针置空,表示链表为空。
具体实现如下:```cvoid InitList(LinkList *L){*L = NULL;}```2. 判断链表是否为空判断链表是否为空可以通过判断链表的头指针是否为空来实现。
具体实现如下:```cint ListEmpty(LinkList L){return L == NULL;}```3. 求链表的长度求链表的长度即统计链表中节点的个数。
具体实现如下:```cint ListLength(LinkList L){int count = 0;Node *p = L;while(p != NULL){count++;p = p->next;}return count;}```4. 插入节点插入节点可以在链表的任意位置插入新的节点。
具体实现如下:```cint ListInsert(LinkList *L, int pos, int data){if(pos < 1 || pos > ListLength(*L) + 1){return 0;}Node *p = *L;Node *newNode = (Node*)malloc(sizeof(Node));newNode->data = data;newNode->next = NULL;if(pos == 1){newNode->next = *L;*L = newNode;}else{for(int i = 1; i < pos - 1; i++){p = p->next;}newNode->next = p->next;p->next = newNode;}return 1;}```5. 删除节点删除节点可以删除链表中指定位置的节点。
C语言的循环链表和约瑟夫环
C语言的循环链表和约瑟夫环C语言的循环链表和约瑟夫环约瑟夫问题)是一个数学的应用问题,对于学习C语言四非常挺有帮助的,下面是店铺为大家搜集整理出来的有关于C语言的循环链表和约瑟夫环,一起了解下吧!循环链表的实现单链表只有向后结点,当单链表的尾链表不指向NULL,而是指向头结点时候,形成了一个环,成为单循环链表,简称循环链表。
当它是空表,向后结点就只想了自己,这也是它与单链表的主要差异,判断node->next是否等于head。
代码实现分为四部分:1. 初始化2. 插入3. 删除4. 定位寻找代码实现:1 2 3 4 5 6 7 8 9 1 0 1 1 1 2 1 3 1void ListInit(Node *pNode){int item;Node *temp,*target;cout<<"输入0完成初始化"<<endl; cin="">>item;if(!item)return ;if(!(pNode)){ //当空表的时候,head==NULLpNode = new Node ;if(!(pNode))exit(0);//未成功申请pNode->data = item;pNode->next = pNode;}else{//for(target = pNode;target->next!=pNode;target = target->next);4 15 16 17 18 19 2 0 2 1 2 2 2 3 2 4 2 5 2 6 2 7 2 8 2 9 3 0 3 1 3 2 3 3 3 4 3 5 3temp = new Node;if(!(temp))exit(0);temp->data = item;temp->next = pNode;target->next = temp;}}}void ListInsert(Node *pNode,int i){ //参数是首节点和插入位置Node *temp;Node *target;int item;cout<<"输入您要插入的值:"<<endl; cin="">>item;if(i==1){temp = new Node;if(!temp)exit(0);temp->data = item;for(target=pNode;target->next != pNode;target = target->next);temp->next = pNode;target->next = temp;pNode = temp;}else{target = pNode;for (int j=1;j<i-1;++j) target="target-">next;temp = new Node;if(!temp)exit(0);temp->data = item;temp->next = target->next;target->next = temp;}}void ListDelete(Node *pNode,int i){Node *target,*temp;if(i==1){for(target=pNode;target->next!=pNode;target=target ->next);temp = pNode;//保存一下要删除的首节点 ,一会便于释放6 37 38 39 4 0 4 1 4 2 4 3 4 4 4 5 4 6 4 7 4 8 4 9 5 0 5 1 5 2 5 3 5 4 5 5 5 6 5 7 5pNode = pNode->next;target->next = pNode;temp;}else{target = pNode;for(int j=1;j<i-1;++j) target="target-">next;temp = target->next;//要释放的nodetarget->next = target->next->next;temp;}}int ListSearch(Node *pNode,int elem){ //查询并返回结点所在的位置Node *target;int i=1;for(target = pNode;target->data!=elem && target->next!= pNode;++i)target = target->next;if(target->next == pNode && target->data!=elem)return 0;else return i;}</i-1;++j)></i-1;++j)></endl;></endl;>5 96 0 6 1 6 2 6 3 6 4 6 5 6 6 67 68 69 7 0 7 1 7 2 7 3 7 4 7 5 7 6 7 7 7 8 7 9 8约瑟夫问题约瑟夫环(约瑟夫问题)是一个数学的'应用问题:已知n个人(以编号1,2,3…n分别表示)围坐在一张圆桌周围。
《C语言链表》课件
详细描述
删除链表中的节点需要找到要删除的节点,修改其前一个节点的指针,使其指向要删除节点的下一个 节点,然后将要删除节点的指针置为NULL。如果要删除的是头节点或尾节点,还需要对头指针或尾 指针进行相应的修改。
遍历链表
总结词
了解如何遍历链表中的所有节点
VS
详细描述
遍历链表需要从头节点开始,依次访问每 个节点,直到达到链表的尾部。在遍历过 程中,可以使用一个指针变量来指向当前 节点,每次循环将指针向后移动一个节点 ,即修改指针的next指针。
链表和循环链表的主要区别在于它们的最后一个节点指向的方向。在链表中,最后一个节点指向NULL; 而在循环链表中,最后一个节点指向第一个节点。循环链表具有更好的性能,但实现起来相对复杂一些 。
05
总结与展望
总结链表的重要性和应用场景
总结1
链表作为C语言中一种基本的数据结构,在计算机科学中 有着广泛的应用。通过学习链表,可以更好地理解数据 结构的基本概念,提高编程能力和解决实际问题的能力 。
详细描述
合并两个有序链表可以通过比较两个链表的 节点值来实现。从头节点开始比较,将较小 的节点添加到结果链表中,并将指针向后移 动。重复此过程直到其中一个链表为空。如 果还有剩余的节点,将其添加到结果链表的 末尾。这种方法的时间复杂度为O(n),其中
n为两个链表中节点的总数。
04
常见错误与注意事项
内存泄漏问题
内存泄漏定义
在C语言中,内存泄漏是指在使用动 态内存分配函数(如malloc、calloc 、realloc等)分配内存后,未能正确 释放这些内存,导致程序运行过程中 不断占用越来越多的内存,最终可能 导致程序崩溃或性能下降。
c语言list定义
c语言list定义C语言中的List(链表)定义和使用链表(List)是一种常见的数据结构,它在C语言中被广泛使用。
链表是由节点(Node)组成的,每个节点包含数据以及指向下一个节点的指针。
相比于数组,链表的长度可以动态调整,更加灵活。
1. 链表的定义与结构在C语言中,我们可以使用结构体来定义链表的节点。
一个简单的链表节点定义如下:```cstruct Node {int data; // 存储的数据struct Node* next; // 指向下一个节点的指针};```2. 创建链表要创建一个链表,我们首先需要定义一个指向链表头部的指针,通常称为头指针(head)。
创建一个空链表的步骤如下:```cstruct Node* head = NULL; // 初始化头指针为空```3. 插入节点链表的插入操作通常包括在链表的头部或尾部插入节点,以及在指定位置插入节点。
下面是几个常见的插入操作示例:在链表头部插入节点:```cstruct Node* newNode = (struct Node*)malloc(sizeof(struct Node)); // 创建新节点newNode->data = 1; // 设置新节点的数据newNode->next = head; // 将新节点的next指针指向当前头节点head = newNode; // 更新头指针,使其指向新节点```在链表尾部插入节点:```cstruct Node* newNode = (struct Node*)malloc(sizeof(struct Node)); // 创建新节点newNode->data = 2; // 设置新节点的数据newNode->next = NULL; // 将新节点的next指针设置为NULL,表示链表的末尾struct Node* cur = head;while (cur->next != NULL) {cur = cur->next; // 遍历链表,找到最后一个节点}cur->next = newNode; // 将新节点连接到最后一个节点的next 指针上```在指定位置插入节点:```cstruct Node* newNode = (struct Node*)malloc(sizeof(struct Node)); // 创建新节点newNode->data = 3; // 设置新节点的数据struct Node* cur = head;while (cur->data != 2) {cur = cur->next; // 遍历链表,找到要插入节点的位置}newNode->next = cur->next; // 将新节点的next指针指向原位置的节点cur->next = newNode; // 将新节点连接到指定位置的节点的next指针上```4. 删除节点删除链表中的节点通常包括删除头节点、尾节点以及指定位置的节点。
c语言中链表的作用
c语言中链表的作用
C语言中的链表是一种常用的数据结构,它可以用来存储一系列数据,这些数据之间通过指针相互连接,形成一个链式结构。
链表的作用主要有以下几个方面:
1. 动态存储数据:链表可以动态地分配内存,这意味着我们可以根据需要随时添加或删除数据,而不用担心内存空间不足的问题。
2. 方便插入和删除操作:由于链表的每个节点都有指针指向下一个节点,所以插入或删除操作只需要改变一些指针的指向,而不用移动整个链表。
3. 实现高效的算法:链表可以用来实现很多高效的算法,比如快速排序、归并排序、深度优先搜索和广度优先搜索等。
4. 数据结构的组合:链表可以和其他数据结构组合使用,比如栈和队列,这样可以实现更复杂的算法和数据结构。
总之,链表是一种非常实用的数据结构,它在C语言中的应用非常广泛,尤其是在高性能计算和数据处理方面。
掌握链表的基本原理和操作方法,对于C语言程序员来说是非常必要的。
- 1 -。
C语言基础入门:链表详解篇
C语⾔基础⼊门:链表详解篇 链表是⼀种常见的重要的数据结构。
它是动态地进⾏存储分配的⼀种结构。
它可以根据需要开辟内存单元。
链表有⼀个“头指针”变量,以head表⽰,它存放⼀个地址。
该地址指向⼀个元素。
链表中每⼀个元素称为“结点”,每个结点都应包括两个部分: ⼀为⽤户需要⽤的实际数据,⼆为下⼀个结点的地址。
因此,head指向第⼀个元素:第⼀个元素⼜指向第⼆个元素;……,直到最后⼀个元素,该元素不再指向其它元素,它称为“表尾”,它的地址部分放⼀个“NULL”(表⽰“空地址”),链表到此结束。
链表的各类操作包括:学习单向链表的创建、删除、插⼊(⽆序、有序)、输出、排序(选择、插⼊、冒泡)、反序等等。
基本操作 1. 节点的构造 #include #include #include #defineLEN sizeof(struct stu)structstu{ //数据char num[10];char name[20];float score; //指针structstu*next;}; 2. 建⽴链表 struct stu *create(){ /structstu*head;structstu*p1, *p2; head = (struct stu *)malloc(LEN); head->next =NULL; p1 = head; p2 = (struct stu *)malloc(LEN); printf("输⼊个⼈信息:学籍号、姓名和总成绩\n"); scanf("%s%s%f",p2->num, p2->name, &p2->score); getchar(); while(strcmp(p2->num,"0") !=0){/* 执⾏结束后 1。
p2的next域为NULL. 2。
第⼀个节点的next域指向第⼆个节点的数据域 3。
c语言链表定义
c语言链表定义链表是一种非常基础的数据结构,它的定义可以用多种编程语言来实现,其中最为常见的就是C语言。
本文将着重介绍C语言的链表定义。
第一步:首先,我们需要定义一个链表节点的结构体,用来存储链表中每个节点的数据信息以及指向下一个节点的指针。
具体代码如下所示:```struct ListNode {int val;struct ListNode *next;};```在这个结构体中,我们定义了两个成员变量,一个是表示节点值的val,一个是表示指向下一个节点的指针next。
其中,节点值可以是任意类型的数据,而指针next则是一个指向结构体类型的指针。
第二步:我们需要定义链表的头节点,通常会将头节点的指针定义为一个全局变量,方便在程序的不同部分中都能够访问。
这个头节点的作用是指向链表的第一个节点,同时也充当了哨兵节点的作用,使得链表的操作更加方便。
具体代码如下所示:```struct ListNode *list_head = NULL;```在这个全局变量中,我们定义了一个指向链表头节点的指针list_head,并将它初始化为NULL,表示目前链表为空。
第三步:链表的基本操作主要包括创建、插入、删除和遍历等。
我们将逐一介绍它们的定义方法。
1. 创建链表创建链表时,我们需要动态地分配内存,以保证每个节点的空间都是连续的而不会被覆盖。
具体代码如下所示:```struct ListNode *create_list(int arr[], int n) {struct ListNode *head = NULL, *tail = NULL;for (int i = 0; i < n; i++) {struct ListNode *node = (struct ListNode*)malloc(sizeof(struct ListNode));node->val = arr[i];node->next = NULL;if (head == NULL) {head = node;tail = node;} else {tail->next = node;tail = node;}}return head;}```在这个代码中,我们首先定义了链表的头节点head和尾节点tail,并将它们初始化为空。
C语言-链表
NWPU—CC—ZhangYanChun
13
┇
void main( )
{┇
for(i=1; i<=N; i++)
/*建立链表*/
{┇
}
for(i=1; i<=N; i++)
/*输出链表*/
{ if(i==1) p1=head;
/*p1指向首节点*/
else p1=p1->next; /*p1指向下一节点*/
第第9十页,一共2章8页。 结构体与共用体
NWPU—CC—ZhangYanChun
10
3) 重复第2步,建立并链接多个节点直至所需长
度,将末尾节点的next成员赋值0。
head
1048 p1 1370 p1
2101
2304
1012
2918
89.5
90
85
操作:
1370
1012
NULL
pp22
p2
p1=(struct student *)malloc(len);
成功,返回存储块起始指针,该指针类型为
void *;否则返回空指针(NULL)。
内存释放函数原形:void free(void *p); 功能:释放p所指向的内存块。
包含文件:malloc.h、stdlib.h中均有其原型声明。
C 程序设计
第第4十页,一共2章8页。 结构体与共用体
NWPU—CC—ZhangYanChun
第第5十页,一共2章8页。 结构体与共用体
NWPU—CC—ZhangYanChun
6
6) 链表的类型
单链表:每个节点只有一个指向后继节点的指针 双向链表:每个节点有两个用于指向其它节点的指针;
c++链表的详细讲解
c++链表的详细讲解链表是一种常见的数据结构,可以通过节点之间的指针关系将多个元素有序地连接起来。
链表的内存分配是动态的,可以根据实际的需求进行灵活的扩展和收缩,相较于数组有着更好的插入和删除操作性能。
链表由多个节点组成,每个节点包含两部分:一个是数据部分,用来存储实际的元素值;另一个是指针部分,用来指向下一个节点。
在C++中,通过结构体或类定义节点,使用指针来连接节点之间的关系。
一、单链表单链表是最简单的链表形式,每个节点只有一个指针指向下一个节点,最后一个节点的指针指向空。
单链表的头节点为链表的入口,通过遍历操作可以访问到链表中的每一个节点。
1.定义节点结构体```cppstruct Node{int data;Node* next;};```节点结构体包含一个整型数据成员data,用来存储元素值;一个指向下一个节点的指针成员next。
2.创建链表创建链表需要分配内存,并将指针进行连接。
```cppNode* createLinkedList(int size){Node* head = nullptr; //头节点指针Node* tail = nullptr; //尾节点指针for(int i=0; i<size; i++){Node* newNode = new Node;cout << "请输入第" << i+1 << "个节点的值:";cin >> newNode->data;newNode->next = nullptr; //新节点的next指针置为空if(head == nullptr){ //如果是第一个节点head = newNode; //头节点指针指向第一个节点tail = newNode; //尾节点指针指向第一个节点}else{ //如果不是第一个节点tail->next = newNode; //将尾节点的next指针指向新节点tail = newNode; //尾节点指针指向新节点}}return head; //返回头节点指针}```函数createLinkedList接受一个参数size,表示链表的长度,返回一个头节点的指针。
C语言链表详解及代码分析
C语⾔链表详解及代码分析⽬录什么是链表环境构建建⽴静态链表包含所需要的头⽂件宏定义相关变量创建⼀个结构体主函数结果展⽰说明建⽴动态链表包含所需要的头⽂件宏定义相关变量创建⼀个结构体建⽴链表函数主函数结果展⽰链表的输出输出函数主函数链表的修改主函数删除函数主函数输出结果插⼊函数主函数结果显⽰出现的问题什么是链表链表是⼀种常见的重要的数据结构。
它是动态地进⾏存储分配的⼀种结构。
链表和数组⽐较,不⽤事先确定存储空间,⽽是根据需要开辟内存单元。
下图1是最简单的⼀种链表(单向链表)的结构第 0 个结点称为头结点,它存放有第⼀个结点的⾸地址,它没有数据,只是⼀个指针变量。
以下的每个结点都分为两个域,⼀个是数据域,存放各种实际的数据,如学号 num,姓名name,性别 sex 和成绩 score 等。
另⼀个域为指针域,存放下⼀结点的⾸地址。
链表中的每⼀个结点都是同⼀种结构类型。
环境构建⽤的Visual Studio 2019软件在源⽂件中添加C⽂件建⽴静态链表包含所需要的头⽂件#include<stdio.h> //标准输⼊输出头⽂件#include<stdlib.h>//包含了C、C++语⾔的最常⽤的系统函数宏定义相关变量#define LEN sizeof(struct Student)//宏定义节点长度得命名#define TYPE struct Student//宏定义结构体变量命名创建⼀个结构体struct Student//定义⼀个学⽣类型结构体,包括学号,分数{long num;float score;struct Student* next;//next是指针变量,指向结构体变量};//指向结构体对象得指针变量既可以指向结构体变量,也可以指向结构体数组中得元素主函数int main(){TYPE* head,*p;//定义头指针struct Student a,b,c;//定义三个结构体变量a.num = 101; a.score = 20;//分别对三个结点赋值b.num = 102; b.score = 20;c.num = 103; c.score = 20;/*1、A.B则A为对象或者结构体2、A->B则A为指针,->是成员提取,A->B是提取A中的成员B,A只能是指向类、结构、联合的指针;*/head = &a;a.next = &b;b.next = &c;c.next = NULL;p = head;//把⾸地址给变量do{printf("%ld %5.1f\n",p->num,p->score);//输出每个结点信息p = p->next;//使P指向下⼀个结点} while (p != NULL);//直到指针域指向空值return 0;}结果展⽰说明将第⼀个结点的起始地址赋值给头指针head,将第⼆个结点的起始地址赋值给第⼀个结点的next成员,将第⼆个结点的起始地址赋给第⼀个结点的next…第三个结点的next赋值为NULL,这就形成了简单的链表。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
c语言链表解析
编程思想:
链表由一系列不必在内存中相连的结构组成。
每一个结构均含有表元素和指向包含该元素后继元的结构指针。
我们称之为next指针。
最后一个单元的next指针指向NULL;该值由C定义并且不能与其它指针混淆。
ANSI C规定NULL为零。
指针变量是包含存储另外某个数据的地址的变量。
因此,如果P被声明为指向一个结构的指针,那么存储在P中的值就被解释为内存中的一个位置,在该位置能够找到一个结构。
该结构的一个域可以通过P->FileName访问,其中FileName是我们要考察的域的名字。
如图1所示,这个表含有五个结构,恰好在内存中分配给它们的位置分别是1000,800,712,992和692。
第一个结构的指针含有值800,它提供了第二个结构所在的位置。
其余每个结构也都有一个指针用于类似的目的。
当然,为了访问该表,我们需要知道在哪里能够找到第一个单元。
图1
为了执行打印表PrinList(L)或查找表Find(L,key),只要将一个指针传递到该表的第一个元素,然后用一些Next指针穿越该表即可。
删除命令可以通过修改一个指针来实现。
图2给出在原表中删除第三个元素的结果。
图2
插入命令需要使用一次malloc调用从系统得到一个新单元并在此后执行两次指针调整。
想法通过图3给出,其中虚线表示原来的指针。
图3
程序设计:
上面的描述实际上足以使每一部分都能正常工作,但还是有几处地方可能会出问题:
1、并不存在从所给定义出发在表的前面插入元素的真正显性的方法。
2、从表的前面实行删除是一个特殊情况,因为它改变了表的起始端;编程的疏忽将会造成表的丢失。
3、在执行删除命令时,要求我们记住被删除元素前面的表元。
事实上,稍作一个简单的变化就能够解决所有这三个问题。
做一个标志节点——表头(header)。
图4表示一个带头头结点的链表。
图4
为了避免删除操作相关的一些问题,我们需要编写一个FindPrevious函数,它将返回我们要删除的表元的前驱元的位置。
如果我们使用表头,那么当删除表的第一个元素时,FindPrevious将返回表头的位置。
代码实现:
按照C的约定,作为类型的List(表)和Position(位置)以及函数的原型都列在所谓的.h 头文件中。
具体的Node(节点)声明则在.c文件中。
代码1、链表的类型声明
#ifndef _List_H
struct Node;
typedef struct Node *PtrToNode;
typedef PtrToNode List;
typedef PtrToNode Posotion;
List MakeEmpty(List L);
int IsEmpty(List L);
int IsLast(Position P, List L);
Position Find(ElementType X, List L);
void Delete(ElementType X, List L);
Position FindPrevious(ElementType X, List L);
void Insert(ElementType X, List L, Position P);
void DeleteList(List L);
struct Node
{
ElementType Elment;
Position Next;
}
代码2、测试一个链表是否是空表的函数。
(头结点的Next指向NULL时为空链表)
int IsEmpty(List L)
{
return L->Next == NULL;
}
代码3、测试当前位置是否是链表末尾的函数
int IsLast(Position P, List L)
{
return P->Next == NULL;
}
代码4、查找某个结点的函数
Position Find(int x, List L)
{
Position P;
P = L->Next;
while(P != NULL; && P->Element != X) /*如果与运算的前半部分为假,后半部分则不执行*/
p = p->Next;
return P;
}
代码5、找出含有X的表元的前驱元P的FindPrevious函数
Position FindPrevious(ElementType X, List L)
{
Position P;
P = L;
while(P->Next != NULL && P->Next->Element != X)
P = P->Next;
return P;
}
代码6、删除链表L中的某个元素X函数
void DeleteList(List L)
{
Position P,TmpCell;
P = FindPrevious(X, L)
if(!IsLast(P, L))
{
TmpCell = P->Next;
P->Next = TmpCell->Next;
free(TmpCell);
}
}
代码7、链表的插入函数
void Insert(ElementType X, List L, Position P) { Position TmpCell;
TmpCell = malloc(sizeof(struct Node)); if(TmpCell == NULL)
FataError(“Out of space!”);
TmpCell->Elment = X;
TmpCell->Next = P->Next;
P->Next = TmpCell}。