您的位置：360文档中心› 最全的c语言链表大全

最全的c语言链表大全

合集下载

c语言中linklist类型

c语言中linklist类型

c语言中linklist类型LinkList类型是C语言中常用的数据结构之一，它是一种线性链表的实现方式。

在计算机科学中，链表是一种常见的数据结构，用于存储和操作一系列元素。

链表由一系列节点组成，每个节点包含一个数据元素和一个指向下一个节点的指针。

链表中的第一个节点称为头节点，最后一个节点称为尾节点。

链表可以根据需要动态地增加或删除节点，相比于数组，链表的大小可以根据实际需求进行调整。

链表的实现可以使用不同的方式，其中最常见的是单向链表。

在单向链表中，每个节点只有一个指针，指向下一个节点。

这种实现方式简单且高效，适用于大多数场景。

除了单向链表，还有双向链表和循环链表等其他实现方式。

链表的优点是可以快速在任意位置插入或删除节点，而无需移动其他节点。

这是由于链表中的节点通过指针相互连接，而不是像数组那样连续存储。

另外，链表的大小可以根据需要进行动态调整，而数组的大小是静态的。

这使得链表在处理动态数据集合时非常有用。

然而，链表也有一些缺点。

首先，访问链表中的任意节点都需要从头节点开始遍历，直到找到目标节点。

这导致了链表的访问时间复杂度为O(n)，而数组的访问时间复杂度为O(1)。

其次，链表需要额外的内存空间来存储指针信息，这会占用更多的存储空间。

在C语言中，可以使用结构体来定义链表节点，例如：```typedef struct Node {int data;struct Node *next;} Node;typedef struct LinkedList {Node *head;Node *tail;} LinkedList;```上述代码定义了一个包含数据和指针的节点结构体Node，以及一个包含头节点和尾节点指针的链表结构体LinkedList。

通过这样的定义，可以方便地进行链表的操作，比如插入、删除和遍历等。

链表的插入操作可以分为三步：创建新节点、修改指针、更新链表的头尾指针。

例如，插入一个新节点到链表末尾的代码如下：```void insert(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. 链表节点的定义cCopy codetypedef struct ListNode { int val; // 节点的值struct ListNode *next; // 指向下一个节点的指针 } ListNode;2. 创建链表cCopy codeListNode* createList(int arr[], int n) { ListNode *head = NULL, *tail = NULL; for (int i = 0; i < n; i++) { ListNode *node = (ListNode *)malloc(sizeof(ListNode)); node->val = arr[i]; node->next = NULL; if (tail == NULL) { head = tail = node; } else { tail->next = node; tail = node; } } return head; }3. 插入节点cCopy codevoid insertNode(ListNode **head, int val, int index) { if (index < 0) { return; } ListNode *node = (ListNode *)malloc(sizeof(ListNode)); node->val = val; node->next = NULL; if (index == 0) { node->next = *head; *head = node; } else { ListNode *prev = *head; for (int i = 0; i < index - 1; i++) { if (prev == NULL) { return; } prev = prev->next; }if (prev == NULL) { return; } node->next = prev->next; prev->next = node; } }4. 删除节点cCopy codevoid deleteNode(ListNode **head, int index) { if (*head == NULL || index < 0) { return; } if (index == 0) { ListNode *node = *head; *head = (*head)->next; free(node); } else { ListNode *prev = *head; for (int i = 0; i < index - 1; i++) { if (prev->next == NULL) { return; } prev = prev->next; } if (prev->next == NULL) { return; } ListNode *node = prev->next; prev->next = node->next; free(node); } }5. 遍历链表cCopy codevoid traverseList(ListNode *head) { while (head != NULL) { printf("%d ", head->val); head = head->next; } printf("\n"); }以上是链表的基本操作代码，可以根据需要进行调整和扩展。

c语言递归反转链表

c语言递归反转链表

在C语言中，递归反转链表的代码实现相对简洁。

下面是一个实现链表反转的递归函数示例：#include <stdio.h>#include <stdlib.h>// 定义链表节点结构体typedef struct ListNode {int val;struct ListNode *next;} ListNode;// 递归函数，用于反转链表ListNode* reverseList(ListNode* head) {// 递归的基准情况：如果链表为空或者只有一个节点，返回原节点if (head == NULL || head->next == NULL) {return head;}// 递归地反转剩下的链表部分ListNode* newHead = reverseList(head->next);// 将当前节点的next指向null（因为它现在是链表的最后一个节点）head->next->next = head;head->next = NULL;// 返回新的头节点return newHead;}// 辅助函数，用于创建链表ListNode* createList(int[] values, int size) {ListNode* head = NULL;for (int i = size - 1; i >= 0; --i) {ListNode* newNode = malloc(sizeof(ListNode));newNode->val = values[i];newNode->next = head;head = newNode;}return head;}// 打印链表void printList(ListNode* head) {while (head != NULL) {printf("%d ", head->val);head = head->next;}printf("\n");}int main() {int values[] = {1, 2, 3, 4, 5};int size = sizeof(values) / sizeof(values[0]);ListNode* originalHead = createList(values, size);printf("Original list: ");printList(originalHead);ListNode* reversedHead = reverseList(originalHead);printf("Reversed list: ");printList(reversedHead);// 释放链表内存ListNode* current = originalHead;while (current != NULL) {ListNode* temp = current;current = current->next;free(temp);}return 0;}这段代码首先定义了一个链表节点结构体ListNode。

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语言链表课件

return counter;
}//Count_LinkList
Void ChangeLinkList(LinkList &L) { LinkList p, q, s, r, t; q=null; r=L; t=null; //r指示原表的表尾，q是临时表 的表头指针，t指示临时表的表尾，p指示当前正在处理的结点 p=L→next; while(p) { if(p→data %2 == 1) { // p结点是奇数结点 s = p; r→next = p→next; //从原表中删除奇 数结点 s→data = s→data + 1; s→next = null; if(!q) { q = s; t = s ; } //在临时表中插入第一 个结点 else { t→next = s; t = s; } }//if else r = r→next; p = p→next; //处理下一个结点 }//while r→next=q; //将临时表链接到原表之后 }//ChangeLinkList
链表
结点(数据元素) = 元素(数据元素的映象) + 指针(指示后继元素存储位置) 结点 元素(data) 指针(next)
用一组地址任意的存储单元存放线性表中的数据元素。
链表：以“结点的序列”表示线性表
使用内存分配函数，动态申请和释放堆中的存储空间。
P124
struct node{//定义节点类型 int data; node * next; };
void main( ) { node * h; h=CreList( ); PrintList(h); }
node *CreList()
{node A_node; node *head; //首地址 node* s; //当前结点 head = NULL; printf("\n Please input the number ( 0 the end):\t"); scanf("%d",&A_node.data);

[转载整理]C语言链表实例

[转载整理]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.检查单链表是否为空，若为空则返回１，否则返回０ */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语言版本）

十字链表（C语言版本）

⼗字链表（C语⾔版本）内容其实跟以前写的⼀样的，改⼀个C语⾔版本。

#include <stdio.h>#include <stdlib.h>#include <math.h>typedef struct DoubleNode {int roleId;int x;int y;struct DoubleNode* xPrev;struct DoubleNode* xNext;struct DoubleNode* yPrev;struct DoubleNode* yNext;} DoubleNode;typedef struct Scene {DoubleNode* _head;DoubleNode* _tail;} Scene;void _add_node(struct Scene* scene, DoubleNode* node);void _leave_scene(DoubleNode* node);// 初始化场景struct Scene* new_scene();// 进⼊场景DoubleNode* enter_scene(struct Scene* scene, int roleId, int x, int y);// 离开场景void leave_scene(DoubleNode* node);// 场景内移动void role_move(struct Scene* scene, DoubleNode* node, int x, int y);// 获取AOIvoid get_aoi(struct Scene* scene, DoubleNode* node, int xAreaLen, int yAreaLen);// --------------------------------------------------struct Scene* new_scene() {struct Scene* scene = (struct Scene*)malloc(sizeof(struct Scene));DoubleNode* _head = (struct DoubleNode*)malloc(sizeof(struct DoubleNode));DoubleNode* _tail = (struct DoubleNode*)malloc(sizeof(struct DoubleNode));_head->roleId = _head->x = _head->y = 0;_tail->roleId = _tail->x = _tail->y = 0;_head->xPrev = _tail->xNext = NULL;_head->yPrev = _tail->yNext = NULL;_head->xNext = _head->yNext = _tail;_tail->xPrev = _tail->yPrev = _head;scene->_head = _head;scene->_tail = _tail;return scene;}DoubleNode* enter_scene(struct Scene* scene, int roleId, int x, int y) {DoubleNode* node = (DoubleNode*)malloc(sizeof(DoubleNode));node->roleId = roleId;node->x = x;node->y = y;_add_node(scene, node);return node;}void _add_node(struct Scene* scene, DoubleNode* node) {DoubleNode* cur = scene->_head->xNext;while(cur != NULL){if((cur->x > node->x) || cur == scene->_tail) {node->xNext = cur;node->xPrev = cur->xPrev;cur->xPrev->xNext = node;cur->xPrev = node;break;}cur = cur->xNext;}cur = scene->_head->yNext;while(cur != NULL){if((cur->y > node->y) || cur == scene->_tail) {node->yNext = cur;node->yPrev = cur->yPrev;cur->yPrev->yNext = node;cur->yPrev = node;break;}cur = cur->yNext;}}void _leave_scene(DoubleNode* node) {node->xPrev->xNext = node->xNext;node->yPrev->yNext = node->yNext;node->xNext->xPrev = node->xPrev;node->yNext->yPrev = node->yPrev;node->xPrev = node->xNext = NULL;node->yPrev = node->yNext = NULL;}void leave_scene(DoubleNode* node) {_leave_scene(node);free(node);}void print_scene(struct Scene* scene) {DoubleNode* cur = scene->_head->xNext;while(cur != scene->_tail) {printf("%d(%d, %d)\n", cur->roleId, cur->x, cur->y);cur = cur->xNext;}printf("\n");cur = scene->_head->yNext;while(cur != scene->_tail) {printf("%d(%d, %d)\n", cur->roleId, cur->x, cur->y);cur = cur->yNext;}}void role_move(struct Scene* scene, DoubleNode* node, int x, int y) {_leave_scene(node);node->x = x;node->y = y;_add_node(scene, node);}void get_aoi(struct Scene* scene, DoubleNode* node, int xAreaLen, int yAreaLen) { DoubleNode* cur = node->xNext;while(cur != scene->_tail){if(cur->x < node->x + xAreaLen){if(abs(cur->y - node->y) < yAreaLen){printf("aoi = %d(%d, %d)\n", cur->roleId, cur->x, cur->y);}}else{break;}cur = cur->xNext;}cur = node->xPrev;while(cur != scene->_tail){if(node->x < cur->x + xAreaLen){if(abs(cur->y - node->y) < yAreaLen){printf("aoi = %d(%d, %d)\n", cur->roleId, cur->x, cur->y);}}else{break;}cur = cur->xPrev;}}void main() {struct Scene* scene = new_scene();printf("\n== enter_scene == \n");enter_scene(scene, 1001, 1, 5);enter_scene(scene, 1002, 6, 6);enter_scene(scene, 1003, 3, 1);enter_scene(scene, 1004, 2, 2);struct DoubleNode* node1 = enter_scene(scene, 1005, 5, 4); struct DoubleNode* node2 = enter_scene(scene, 1006, 3, 3); print_scene(scene);printf("\n== leave_scene == \n");leave_scene(node1);print_scene(scene);printf("\n== role_move == \n");role_move(scene, node2, 2, 2);print_scene(scene);printf("\n== get_aoi == \n");get_aoi(scene, node2, 2, 2);}。

c语言中linklist类型

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语言四非常挺有帮助的，下面是店铺为大家搜集整理出来的有关于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语言链表总结_单链表_详细备注版本

c语言链表总结_单链表_详细备注版本

链表是学习数据结构的大门，在微软等大公司招聘c\c++技术人员的时候有3个会必然出现的东西，指针、链表、二叉树！在看一下内容时请确认您已经熟悉C语言的指针，否则请先复习指针的基础知识。

以下以单链表为说明对象！我从一个初学者的角度来对链表进行说明：理论上的东西大家可以参考c语言数据结构一书，在此主要用一些例子来说明：看下面链表的基本形式：Struct link_c{Char name[20];Struct link_c *link;}可以看到这是一个结构体，结构体中有一个link_c的指针link。

如图所示，head是链表的头指针，他指向链表的第一个节点，如果head为空则说明链表是空的。

而节点中的link指向下一节点的首地址，如果link为空则代表此节点为这个链表的最后一个节点（非循环表，循环表的最后一个link指向head）。

这里要注意的是Link要与他后面所指的节点的结构相同，所以其类型必须是link。

下面我们创建一个简单的链表并且进行基本操作。

//定义链表的基础结构体Struct student{Int num;Struct student *next;};//创建一个只有头节点的空链表Struct student *creat()//返回的是一个结构体指针{Struct student *head;//定义并初始化头指针Head = （struct student *）malloc（sizeof(struct student)）;//如果内存分配失败则返回空If(!head)//这种写法我也很不适应，但是比较规范{Return null;}//head头结点的指向的next为空，链表只有一个节点。

Head->next = NULL;Return head;}以上建立了一个单节点的链表。

接下来可以根据以上代码进行优化修改，创建一个多链接的链表创建有n个节点的链表Struct student *creat( int n )//返回的是一个结构体{Int I;Struct student *head, *p, *s;//定义并初始化头指针Head = （struct student *）malloc（sizeof(struct student)）;//如果内存分配失败则返回空If(!headl){Return null;}P=head;For(i=0,i<n,i++){S=(struct student*)malloc(sizeof(struct student));If(!s){Return null;}p->next= s;s->next=NULL;p=s;//i+1后s的前驱节点就变成了上一循环的s也就是现在的p ，，，此处有点绕}Return head;返回头节点指针}-----------------------------------------------------------------------------------------上面已经建立了一个比较简单的链表结构，下面进行一些链表的基本操作链表的查询操作Struct student *search(struct student *head, int *num)//head是头指针，num是要查找的数据{struct student *p；//定义一个节点指针int *m；//临时保存节点内的数据p=head->next;//头指针是不包含数据的，所以搜索的第一个节点是头指针指向的节点while(p!=NULL)//没有到最后一个节点{M=P->num;If(strcmp(num,m)==0)//strcmp应用可查csdn{Return p;}Else p=p->next;//如果判断不正确则指向下一个节点}If(p==NULL){//没有找到数据，可以做消息弹出}}接下来是链表的插入操作，将s节点插入到p节点以前设结构体中的int num是一个关键字，链表以这个关键字进行的排序Struct student *instert(struct student *s, struct student *head)//s就是要插入的结构体*插入的节////点必须和原链表结构相同。

《C语言链表》课件

《C语言链表》课件
了解如何删除链表中的指定节点
详细描述
删除链表中的节点需要找到要删除的节点，修改其前一个节点的指针，使其指向要删除节点的下一个 节点，然后将要删除节点的指针置为NULL。如果要删除的是头节点或尾节点，还需要对头指针或尾 指针进行相应的修改。
遍历链表
总结词
了解如何遍历链表中的所有节点
VS
详细描述
遍历链表需要从头节点开始，依次访问每 个节点，直到达到链表的尾部。在遍历过 程中，可以使用一个指针变量来指向当前 节点，每次循环将指针向后移动一个节点 ，即修改指针的next指针。
链表和循环链表的主要区别在于它们的最后一个节点指向的方向。在链表中，最后一个节点指向NULL； 而在循环链表中，最后一个节点指向第一个节点。循环链表具有更好的性能，但实现起来相对复杂一些 。
05
总结与展望
总结链表的重要性和应用场景
总结1
链表作为C语言中一种基本的数据结构，在计算机科学中 有着广泛的应用。通过学习链表，可以更好地理解数据 结构的基本概念，提高编程能力和解决实际问题的能力 。
详细描述
合并两个有序链表可以通过比较两个链表的 节点值来实现。从头节点开始比较，将较小 的节点添加到结果链表中，并将指针向后移 动。重复此过程直到其中一个链表为空。如 果还有剩余的节点，将其添加到结果链表的 末尾。这种方法的时间复杂度为O(n)，其中
n为两个链表中节点的总数。
04
常见错误与注意事项
内存泄漏问题
内存泄漏定义
在C语言中，内存泄漏是指在使用动 态内存分配函数（如malloc、calloc 、realloc等）分配内存后，未能正确 释放这些内存，导致程序运行过程中 不断占用越来越多的内存，最终可能 导致程序崩溃或性能下降。

c语言list定义

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语⾔基础⼊门：链表详解篇 链表是⼀种常见的重要的数据结构。

它是动态地进⾏存储分配的⼀种结构。

它可以根据需要开辟内存单元。

链表有⼀个“头指针”变量，以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语言链表详解PPT课件

C语言链表详解PPT课件
撤消原来的链接关系。 两种情况： 1、要删的结点是头指针所指的结点则直接操作； 2、不是头结点，要依次往下找。 另外要考虑：空表和找不到要删除的结点
26
链表中结点删除
需要由两个临时指针： P1: 判断指向的结点是不是要删除的结点 （用于寻找）； P2: 始终指向P1的前面一个结点；
27
图 11.19
4
结点里的指针是存放下一个结点的地址
Head
1249
1249
A 1356
1356
B 1475
1475
C 1021
1021
D Null
1、链表中的元素称为“结点”，每个结点包括两 个域：数据域和指针域；
2、单向链表通常由一个头指针（head)，用于指 向链表头；
3、单向链表有一个尾结点，该结点的指针部分指
7
（4）删除操作是指，删除结点ki，使线性表的长度 减1，且ki-1、ki和ki+1之间的逻辑关系发生如下变 化：
删除前，ki是ki+1的前驱、ki-1的后继；删除后，ki-1 成为ki+1的前驱，ki+1成为ki-1的后继.
(5)打印输出
8
一个指针类型的成员既可指向其它类型的结构体数 据，也可以指向自己所在的结构体类型的数据
(x7,y7)
为了表示这种既有数据又有指针的情况， 引入结构这种数据类型。
3
11.7 用指针处理链表
链表是程序设计中一种重要的动态数据结构， 它是动态地进行存储分配的一种结构。
动态性体现为： 链表中的元素个数可以根据需要增加和减少，不 像数组，在声明之后就固定不变；
元素的位置可以变化，即可以从某个位置删除， 然后再插入到一个新的地方；

C语言动态链表的排序（从小到大）2021.07.14

C语言动态链表的排序（从小到大）2021.07.14

C语⾔动态链表的排序（从⼩到⼤）2021.07.14 //现在的主要问题是，排序的列表中不能出现0，原因是与NULL冲突。

#include <stdio.h>#include <stdlib.h>#define MAX 999999typedef struct LNode//重命名struct LNode为LNode{int data;LNode* next;//在结构体中可以直接使⽤新名字LNode}LNode;void CreateLinklist(LNode*& head){printf("请输⼊数字创建链表，以9999结束。

\n");head = (LNode*)malloc(sizeof(LNode));head->next = nullptr;LNode* flag;flag = head;int t;scanf_s("%d", &t);while (t != 9999){flag->data = t;flag->next = (LNode*)malloc(sizeof(LNode));flag = flag->next;scanf_s("%d", &t);}flag->next = nullptr;flag = head;}void printLinklist(LNode* p){if (p->data == NULL)printf("链表为空。

\n");else{printf("链表的结构为:\n");while (p->next != nullptr){printf("%d", p->data);p = p->next;if (p->next != nullptr)printf(" -> ");}}}void CopyLinklist(LNode*& head, LNode* b){head = (LNode*)malloc(sizeof(LNode));head->next = nullptr;LNode* flag;flag = head;while (b->next != nullptr){flag->data = b->data;flag->next = (LNode*)malloc(sizeof(LNode));flag = flag->next;b = b->next;}flag->next = nullptr;flag = head;}void sort(LNode*& headA, LNode* p){LNode* copy;CopyLinklist(copy, p);headA = (LNode*)malloc(sizeof(LNode));headA->next = nullptr;LNode* flagA;LNode* flagB;LNode* flagC;flagA = headA;flagB = copy;flagC = copy;int g;int num = 0;while (copy->next != nullptr){copy = copy->next;num++;}printf("该排序链表共有%d个结点。

C语言-链表

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) 链表的类型
单链表：每个节点只有一个指向后继节点的指针 双向链表：每个节点有两个用于指向其它节点的指针；
  1. 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。

STU *creat4(void) //方法4，不会产生多余的结点，不用free { STU *p1, *head=NULL; int num; float score; printf("输入学生的学号和成绩, (全输0时结束):\n"); scanf("%d%f", &num, &score); while ( num!=0 ) { p1=(STU *) malloc (LEN); p1->num=num; p1->score=score; p1->next=head; head=p1; scanf("%d%f", &num, &score); } return(head); }
实验8参考程序
实验8：表首添加法建立链表，连接两个链表 #include<stdio.h> #include<stdlib.h> typedef struct stu_node { int num ; float score ; struct stu_node *next ; }STU; #define LEN sizeof(STU)
STU *creat2(void) //方法2 { STU *p1, *p2=NULL, *head=NULL; printf(“输入学生的学号和成绩，(全输0时结束)：\n"); p1=( STU *) malloc (LEN); scanf("%d%f", &p1->num, &p1->score); while ( p1->num!=0 ) { head=p1; p1->next=p2; p2=p1; p1=(STU *) malloc (LEN); scanf("%d%f", &p1->num, &p1->score) ; } free(p1); return(head); }
void main( ) { STU *h1,*h2; printf("建立链表1: \n"); h1=creat ( ); printf("建立链表2: \n"); h2=creat( ); printf("输出链表1:\n"); list(h1); printf("输出链表2:\n"); list(h2); connect(h1, h2); printf("输出连接后的链表: \n"); list(h1); }
STU *creat(void) ; void list(STU *head); void connect (STU *head1, STU *head2);
实验8：表首添加法建立链表，连接两个链表 STU *c=NULL; printf(“输入学生的学号和成绩，(全输0时结束)：\n"); p1=p2=( STU *) malloc (LEN); scanf("%d%f", &p1->num, &p1->score); while ( p1->num!=0 ) { if (head==NULL) p1->next=NULL; else p1->next=p2; head=p1; p2=p1; p1=(STU *) malloc (LEN); scanf("%d%f", &p1->num, &p1->score) ; } free(p1); return(head); }
void connect (STU *head1, STU *head2) //连接两个链表 { STU *p; p=head1; //p指向链表1的表头结点 while(p->next!=NULL) //循环结束时p指向链表1的表尾结点 p=p->next; p->next=head2; //将链表1的表尾结点与链表2的表头结点连起来 }
STU *creat3(void) //方法3, 省略指针变量p2 { STU *p1, *head=NULL; printf(“输入学生的学号和成绩，(全输0时结束)：\n"); p1=( STU *) malloc (LEN); scanf("%d%f", &p1->num, &p1->score); while ( p1->num!=0 ) { p1->next=head; head=p1; p1=(STU *) malloc (LEN); scanf("%d%f", &p1->num, &p1->score); } free(p1); return(head); }
void list(STU *head) { STU *p; if (head==NULL) printf("链表为空！\n"); else { printf("链表信息如下:\n"); p=head; while (p!=NULL) { printf("%d, %5.2f\n", p->num, p->score); p=p->next; //令p指向下一个结点 } } }
相关文档
最新文档