link——纯C语言实现单链表的基本操作
单链表的基本操作
10）调用头插法的函数，分别输入10,20，分别回车：
11）调用尾插法的函数，分别输入30,40
12）查找单链表的第四个元素：
13）主函数中传入参数，删除单链表的第一个结点：
14）主函数传入参数，删除第0个未位置的元素，程序报错：
15）最后，输出单链表中的元素：
return 0;
}
6）编译，连接，运行源代码：
7）输入8，回车，并输入8个数，用空格分隔开，根据输出信息，可以看出，链表已经拆分为两个
五、实验总结
1.单链表采用的是数据+指针的表示形式，指针域总是指向下一个结
点（结构体）的地址，因此，在内存中的地址空间可以是不连续的，操作比顺序存储更加的方便
2.单链表使用时，需要用malloc函数申请地址空间，最后，删除元
素时，使用free函数释放空间。
单链表的基本操作
单链表的基本操作《》⼀节我们学习了如何使⽤存储数据元素，以及如何使⽤ C 语⾔创建链表。
本节将详细介绍对链表的⼀些基本操作，包括对链表中数据的添加、删除、查找（遍历）和更改。
注意，以下对链表的操作实现均建⽴在已创建好链表的基础上，创建链表的代码如下所⽰：1. //声明节点结构2. typedef struct Link{3. int elem;//存储整形元素4. struct Link *next;//指向直接后继元素的指针5. }link;6. //创建链表的函数7. link * initLink(){8. link * p=(link*)malloc(sizeof(link));//创建⼀个头结点9. link * temp=p;//声明⼀个指针指向头结点，⽤于遍历链表10. //⽣成链表11. for (int i=1; i<5; i++) {12. //创建节点并初始化13. link *a=(link*)malloc(sizeof(link));14. a->elem=i;15. a->next=NULL;16. //建⽴新节点与直接前驱节点的逻辑关系17. temp->next=a;18. temp=temp->next;19. }20. return p;21. }从实现代码中可以看到，该链表是⼀个具有头节点的链表。
由于头节点本⾝不⽤于存储数据，因此在实现对链表中数据的"增删查改"时要引起注意。
链表插⼊元素同⼀样，向链表中增添元素，根据添加位置不同，可分为以下 3 种情况：插⼊到链表的头部（头节点之后），作为⾸元节点；插⼊到链表中间的某个位置；插⼊到链表的最末端，作为链表中最后⼀个数据元素；虽然新元素的插⼊位置不固定，但是链表插⼊元素的思想是固定的，只需做以下两步操作，即可将新元素插⼊到指定的位置：1. 将新结点的 next 指针指向插⼊位置后的结点；2. 将插⼊位置前结点的 next 指针指向插⼊结点；例如，我们在链表{1,2,3,4}的基础上分别实现在头部、中间部位、尾部插⼊新元素 5，其实现过程如图 1 所⽰：图 1 链表中插⼊元素的 3 种情况⽰意图从图中可以看出，虽然新元素的插⼊位置不同，但实现插⼊操作的⽅法是⼀致的，都是先执⾏步骤 1 ，再执⾏步骤 2。
数据结构-单链表基本操作实现（含全部代码）
数据结构-单链表基本操作实现（含全部代码）今天是单链表的实现，主要实现函数如下：InitList(LinkList &L) 参数：单链表L 功能：初始化时间复杂度 O(1)ListLength(LinkList L) 参数：单链表L 功能：获得单链表长度时间复杂度O(n)ListInsert(LinkList &L,int i,ElemType e) 参数：单链表L,位置i，元素e 功能：位置i后插时间复杂度O(n)[加⼊了查找]若已知指针p指向的后插 O(1)ListDelete(LinkList &L,int i) 参数：单链表L，位置i 功能：删除位置i元素时间复杂度O(n)[加⼊了查找]若已知p指针指向的删除最好是O(1),因为可以与后继结点交换数据域，然后删除后继结点。
最坏是O(n),即从头查找p之前的结点,然后删除p所指结点LocateElem(LinkList L,ElemType e) 参数：单链表L，元素e 功能：查找第⼀个等于e的元素，返回指针时间复杂度O(n)代码：/*Project: single linkeed list (数据结构单链表)Date: 2018/09/14Author: Frank YuInitList(LinkList &L) 参数：单链表L 功能：初始化时间复杂度 O(1)ListLength(LinkList L) 参数：单链表L 功能：获得单链表长度时间复杂度O(n)ListInsert(LinkList &L,int i,ElemType e) 参数：单链表L,位置i，元素e 功能：位置i后插时间复杂度O(n)[加⼊了查找]若已知指针p指向的后插 O(1)ListDelete(LinkList &L,int i) 参数：单链表L，位置i 功能：删除位置i元素时间复杂度O(n)[加⼊了查找]若已知p指针指向的删除最好是O(1),因为可以与后继结点交换数据域，然后删除后继结点。
c语言单链表的实现
c语言单链表的实现摘要：1.引言2.C 语言单链表的基本概念3.单链表的结构定义4.单链表的创建5.单链表的插入6.单链表的删除7.单链表的遍历8.单链表的应用实例9.总结正文：1.引言在计算机科学中，链表是一种重要的数据结构，它允许我们在运行时插入和删除元素。
C 语言是一种广泛使用的编程语言，其中包含了对链表的支持。
本文将介绍C 语言单链表的实现。
2.C 语言单链表的基本概念单链表是一种线性数据结构，其中每个元素包含两个部分：数据和指向下一个元素的指针。
这种结构使得我们可以在运行时插入和删除元素，而不需要移动其他元素。
3.单链表的结构定义在C 语言中，我们可以使用结构体来定义单链表的节点。
一个典型的单链表节点定义如下：```typedef struct Node {int data; // 数据部分struct Node *next; // 指向下一个节点的指针} Node;```4.单链表的创建要创建一个单链表，我们需要先创建一个节点，然后将该节点的指针赋值给链表头。
例如：```ode *createList() {Node *head = (Node *)malloc(sizeof(Node)); // 创建一个新节点head->data = 1;head->next = NULL; // 头节点的指针初始化为NULLreturn head;}```5.单链表的插入要在单链表中插入一个新元素，我们需要创建一个新节点，然后将该节点的指针赋值给要插入的位置。
例如：```void insertNode(Node *head, int data) {Node *newNode = (Node *)malloc(sizeof(Node)); // 创建一个新节点newNode->data = data;newNode->next = head; // 新节点的指针指向原链表头return head; // 返回新的链表头}```6.单链表的删除要从单链表中删除一个元素，我们需要遍历链表，找到要删除的元素，并修改指针。
c语言数据结构链表基本操作
c语言数据结构链表基本操作C语言数据结构链表基本操作链表是一种常见的数据结构，用于存储和操作一系列的数据元素。
在C语言中，链表的实现通常使用指针来连接各个节点，每个节点包含数据和指向下一个节点的指针。
本文将介绍链表的基本操作，包括创建链表、插入节点、删除节点和遍历链表。
1. 创建链表创建链表的第一步是定义一个指向链表头节点的指针。
链表头节点是链表的起始位置，通常不存储数据，只用于指向第一个真正存储数据的节点。
可以使用malloc函数动态分配内存空间来创建链表节点，并将头指针指向该节点。
2. 插入节点在链表中插入节点分为两种情况：在链表头部插入和在链表中间或尾部插入。
在链表头部插入节点时，只需要创建一个新节点，并将新节点的指针指向原来的头节点，然后更新头指针指向新节点即可。
在链表中间或尾部插入节点时，需要先找到插入位置的前一个节点，然后创建新节点，并将新节点的指针指向原来的下一个节点，再将前一个节点的指针指向新节点。
3. 删除节点删除链表中的节点需要找到要删除节点的前一个节点，然后修改前一个节点的指针指向要删除节点的下一个节点，最后释放要删除节点的内存空间。
4. 遍历链表遍历链表是指依次访问链表中的每个节点，并对节点进行操作。
可以使用循环结构和指针来实现链表的遍历。
从链表头节点开始，通过指针指向下一个节点，直到指针为空或指向链表尾部。
链表的基本操作是在实际编程中经常使用的，它可以灵活地插入、删除和修改节点，适用于各种场景。
例如，可以使用链表来实现栈、队列等数据结构，也可以用于在内存中动态存储数据。
在使用链表时，需要注意以下几点：- 确保链表的头指针始终指向链表的起始位置，避免丢失链表的引用。
- 在插入和删除节点时，要注意更新链表的指针，以保持链表的正确性。
- 在释放链表内存空间时，要遍历链表并依次释放每个节点的内存空间，防止内存泄漏。
链表是一种重要的数据结构，灵活性和可扩展性使其在实际应用中具有广泛的用途。
单链表（C语言实现）
单链表（C语⾔实现）链表结构：SList.h//--------------------------------------------------------------------------/***功能：应⽤C语⾔实现单链表的各项操作****** 1：建⽴节点** 2：打印单链表** 3：尾插** 4：尾删** 5：头插** 6：头删** 7：清空整个链表** 8：获取链表长度** 9：查找数据** 10：在某位置后插⼊数据** 11：删除某位置的数据** 12：删除⼀个⽆头单链表的⾮尾节点** 13：在⽆头单链表的⼀个⾮头节点前插⼊⼀个节点** 14：查找中间节点** 15：查找倒数第k个节点(要求只能遍历⼀次)** 16：倒着打印单链表** 17：逆置单链表** 18：合并两个有序链表（合并后依然有序）** 19：冒泡排序****** By ：Lynn-Zhang***///---------------------------------------------------------------------------#pragma oncetypedef int DataType;typedef struct SListNode{DataType data; // 数据struct SListNode* next; //指向下⼀个节点的指针}SListNode;// 如果要修改链表就必须加引⽤SListNode* _BuyNode(DataType x); //建⽴节点void PrintSlist(SListNode* pHead); //打印单链表void PushBack(SListNode* & pHead, DataType x); //尾插(这⾥⽤了引⽤，指明是list的别名，调⽤时传参，不⽤传地址)(引⽤在.c⽂件中不可⽤) //void PushBack(SListNode** pHead, DataType x); // 这⾥的第⼀个参数指向链表第⼀个节点的指针的地址（调⽤时传参，传的是地址）void PopBack(SListNode* & pHead); //尾删void PushFront(SListNode* & pHead, DataType x); //头插void PopFront(SListNode* & pHead); //头删void DestoryList(SListNode*& pHead); //清空整个链表int GetSize(SListNode* pHead); //获取链表长度SListNode* Find(SListNode* pHead, DataType x); //查找数据void Insert(SListNode* pos, DataType x); //在某位置后插⼊数据void Erase(SListNode*& pHead, SListNode* pos); //删除某位置的数据void DelNonTailNode(SListNode* pos); //删除⼀个⽆头单链表的⾮尾节点void InsertFrontNode(SListNode* pos, DataType x); // 在⽆头单链表的⼀个⾮头节点前插⼊⼀个节点SListNode* FindMidNode(SListNode* pHead); //查找中间节点SListNode* FindKNode(SListNode* pHead, int k); //查找倒数第k个节点(要求只能遍历⼀次)void PrintTailToHead(SListNode* pHead); //倒着打印单链表（递归）//SListNode* Reverse_(SListNode* pHead); //逆置单链表（需要接收返回值），原链表会被改void Reverse(SListNode*& pHead); // 将原链表逆置SListNode* Merge(SListNode* pHead1, SListNode* pHead2); //合并两个有序链表（合并后依然有序）（递归）void Sort(SListNode* pHead); //冒泡排序SList.cpp#include"SList.h"#include <stdio.h>#include<assert.h>#include <malloc.h>SListNode* _BuyNode(DataType x) //建⽴节点{SListNode* tmp = (SListNode*)malloc(sizeof(SListNode)); tmp->data = x;tmp->next = NULL;return tmp;}void PrintSlist(SListNode* pHead) // 打印单链表{SListNode* cur = pHead;while (cur){printf("%d->", cur->data);cur = cur->next;}printf("NULL\n");}//void PushBack(SListNode** ppHead, DataType x) //尾插//{// assert(ppHead);//// 1.空//// 2.不为空// if(*ppHead == NULL)// {// *ppHead = _BuyNode(x);// }// else// {//// 找尾// SListNode* tail = *ppHead;// while(tail->next != NULL)// {// tail = tail->next;// }//// tail->next = _BuyNode(x);// }//}void PushBack(SListNode* & pHead, DataType x) //尾插{// 1.空// 2.不为空if (pHead == NULL){pHead = _BuyNode(x);}else{// 找尾SListNode* tail = pHead;while (tail->next != NULL){tail = tail->next;}tail->next = _BuyNode(x);}}void PopBack(SListNode* & pHead) // 尾删{//// 1.空// 2.⼀个节点// 3.多个节点//if (pHead == NULL){return;}else if (pHead->next == NULL){free(pHead);pHead = NULL;}else{SListNode* tail = pHead;SListNode* prev = NULL;while (tail->next){prev = tail;tail = tail->next;}free(tail);prev->next = NULL;}}void PushFront(SListNode* & pHead, DataType x) //头插{// 1.空// 2.不空if (pHead == NULL){pHead = _BuyNode(x);}else{SListNode* tmp = _BuyNode(x);tmp->next = pHead;pHead = tmp;}}void PopFront(SListNode*& pHead) //头删{//// 1.空// 2.⼀个节点// 3.⼀个以上的节点//if (pHead == NULL){return;}else if (pHead->next == NULL){free(pHead);pHead = NULL;}else{SListNode* tmp = pHead;pHead = pHead->next;free(tmp);}}void DestoryList(SListNode*& pHead) //清空整个链表{SListNode* cur = pHead;while (cur){SListNode* tmp = cur;cur = cur->next;free(tmp);}pHead = NULL;}int GetSize(SListNode* pHead) //获取链表长度{assert(pHead);SListNode* cur = pHead;int count = 0;while (cur){count++;cur = cur->next;}return count;}SListNode* Find(SListNode* pHead, DataType x) //查找节点{SListNode* cur = pHead;while (cur){if (cur->data == x)return cur;}cur = cur->next;}return NULL;}void Insert(SListNode* pos, DataType x) // 某位置后插⼊节点{assert(pos);SListNode* tmp = _BuyNode(x);tmp->next = pos->next;pos->next = tmp;}void Erase(SListNode*& pHead, SListNode* pos) //删除某位置的节点{assert(pos);assert(pHead);//pos为头结点if (pHead == pos){pHead = pHead->next;free(pos);return;}////SListNode* prev = pHead;while (prev){if (prev->next == pos){prev->next = pos->next;free(pos);break;}prev = prev->next;}}void DelNonTailNode(SListNode* pos) //// 删除⼀个⽆头单链表的⾮尾节点{assert(pos);assert(pos->next);SListNode* del = pos->next;SListNode* dnext = del->next;pos->data = del->data;pos->next = dnext;free(del);}void InsertFrontNode(SListNode* pos, DataType x) // 在⽆头单链表的⼀个⾮头节点前插⼊⼀个节点{assert(pos);SListNode* tmp = _BuyNode(pos->data);tmp->next = pos->next;pos->next = tmp;pos->data = x;}void Sort(SListNode* pHead) //冒泡排序{assert(pHead);int size = GetSize(pHead);for (int i = 0; i < size - 1; i++){SListNode* left = pHead;SListNode* right = pHead->next;for (int j = 0; j < size - i - 1; j++){if (left->data>right->data){int tmp = left->data;left->data = right->data;right->data = tmp;}right = right->next;left = left->next;}}SListNode* FindMidNode(SListNode* pHead) //查找中间节点{SListNode* fast = pHead;SListNode* slow = pHead;while (fast&&fast->next){slow = slow->next;fast = fast->next->next;}return slow;}SListNode* FindKNode(SListNode* pHead, int k) //查找倒数第k个节点{SListNode* fast = pHead;SListNode* slow = pHead;while (fast && k--){fast = fast->next;}if (k > 0){return NULL;}while (fast){slow = slow->next;fast = fast->next;}return slow;}void PrintTailToHead(SListNode* pHead) //倒着打印单链表（递归）{if (pHead){PrintTailToHead(pHead->next);printf("%d ", pHead->data);}}//SListNode* Reverse_(SListNode* pHead) //逆置单链表（需要接收返回值）原链表会被改//{// SListNode* cur = pHead;// SListNode* newHead = NULL;// while (cur)// {// SListNode* tmp = cur;// cur = cur->next;// tmp->next = newHead;// newHead = tmp;// }// return newHead;//}void Reverse(SListNode*& pHead) //逆置单链表（⽆需返回值）{SListNode* cur = pHead;SListNode* newHead = NULL;while (cur){SListNode* tmp = cur;cur = cur->next;tmp->next = newHead;newHead = tmp;}pHead = newHead;//return newHead;}SListNode* Merge(SListNode* pHead1, SListNode* pHead2) //合并两个有序链表（合并后依然有序）递归{if (pHead1 == NULL)return pHead2;else if (pHead2 == NULL)return pHead1;SListNode* pMergedHead = NULL;if (pHead1->data < pHead2->data){pMergedHead = pHead1;pMergedHead->next = Merge(pHead1->next, pHead2); }else{pMergedHead = pHead2;pMergedHead->next = Merge(pHead1, pHead2->next); }return pMergedHead;}Test.cpp#include "SList.h"#include<stdlib.h>//测试⽤例void Test1(){// 尾插打印尾删头插头删清空链表SListNode* list = NULL;PushBack(list, 1);PushBack(list, 2);PushBack(list, 3);PushBack(list, 4);PrintSlist(list);PopBack(list);PrintSlist(list);PushFront(list,0);PrintSlist(list);PopFront(list);PrintSlist(list);DestoryList(list);PrintSlist(list);}void Test2(){// 查找节点在某位置插⼊节点删除某位置节点SListNode* list = NULL;PushBack(list, 1);PushBack(list, 2);PushBack(list, 3);PushBack(list, 4);PrintSlist(list);SListNode* pos = Find(list, 2);Insert(pos, 0);PrintSlist(list);Erase(list, Find(list, 0));PrintSlist(list);}void Test3(){SListNode* list = NULL;PushBack(list, 1);PushBack(list, 2);PushBack(list, 3);PushBack(list, 4);PushBack(list, 5);PushBack(list, 6);PrintSlist(list);// 删除⼀个⽆头单链表的⾮尾节点/*SListNode* pos = Find(list, 2);DelNonTailNode(pos);PrintSlist(list);*/// 在⽆头单链表的⼀个⾮头节点前插⼊⼀个节点/*SListNode* pos = Find(list, 2);InsertFrontNode(pos, 0);PrintSlist(list);*///查找中间节点//PrintSlist(FindMidNode(list));//查找倒数第k个节点//SListNode* ret = FindKNode(list, 2);//PrintSlist(ret);//倒着打印单链表（递归）//PrintTailToHead(list);//逆置单链表//SListNode* ret = Reverse(list);//PrintSlist(ret);//PrintSlist(Reverse_(list));//PrintSlist(list);}void Test4(){ //合并两个有序链表（合并后依然有序） SListNode* list = NULL;PushBack(list, 4);PushBack(list, 2);PushBack(list, 1);PushBack(list, 4);PrintSlist(list);Sort(list);PrintSlist(list);/*SListNode* list1 = NULL;PushBack(list1, 2);PushBack(list1, 3);PushBack(list1, 3);PushBack(list1, 0);PrintSlist(list);Sort(list1);PrintSlist(list1);SListNode* ret = Merge(list, list1);PrintSlist(ret);PrintSlist(list);PrintSlist(list1);*/}int main(){//Test1();//Test2();//Test3();Test4();system("pause");return0;}。
单链表基本操作的实现
单链表基本操作的实现单链表是一种常见的数据结构，它由多个节点组合而成，每个节点包含一个数据元素和一个指向下一个节点的指针。
通过指针，我们可以方便地在单链表中进行插入、删除和遍历等操作。
以下是关于单链表基本操作的实现。
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. 单链表的删除单链表的删除可以分为在链表头部删除、在链表尾部删除和在链表中间删除三种情况。
单链表的基本操作c语言
单链表的基本操作(C语言)什么是单链表单链表（Singly Linked List）是一种常见的数据结构，它由一系列节点组成，每个节点包含一个数据元素和一个指向下一个节点的指针。
每个节点只能访问其后继节点，而无法直接访问前驱节点。
单链表的特点是可以动态地插入和删除节点，相比于数组，具有更好的灵活性和扩展性。
在C语言中，我们可以使用指针来实现单链表。
单链表的基本操作1. 定义单链表结构体在C语言中，我们首先需要定义一个表示单链表的结构体。
结构体包含两个成员：数据元素和指向下一个节点的指针。
typedef struct Node {int data; // 数据元素struct Node *next; // 指向下一个节点的指针} Node;2. 创建单链表创建一个空的单链表需要进行以下步骤：•定义头节点，并初始化为NULL。
•向链表中插入新的节点。
Node* createLinkedList() {Node *head = NULL; // 头节点初始化为NULLint n; // 节点数量printf("请输入要创建的节点数量：");scanf("%d", &n);for (int i = 0; i < n; i++) {int data;printf("请输入第%d个节点的值：", i + 1);scanf("%d", &data);Node *newNode = (Node*)malloc(sizeof(Node)); // 创建新节点newNode->data = data;newNode->next = NULL;if (head == NULL) {head = newNode; // 如果是第一个节点，将其设置为头节点 } else {Node *temp = head;while (temp->next != NULL) {temp = temp->next; // 移动到链表末尾}temp->next = newNode; // 将新节点插入到链表末尾}}return head;}3. 插入节点在单链表中插入一个新的节点需要进行以下步骤：•创建一个新的节点。
数据结构C语言版 线性表的单链表存储结构表示和实现
#include 〈stdio.h>＃include <malloc。
h>＃include 〈stdlib.h>/＊数据结构C语言版线性表的单链表存储结构表示和实现P28—31编译环境：Dev-C++ 4。
9。
9。
2日期：2011年2月10日＊/typedef int ElemType;// 线性表的单链表存储结构typedef struct LNode{ElemType data; //数据域struct LNode *next；//指针域}LNode, ＊LinkList；// typedef struct LNode *LinkList；// 另一种定义LinkList的方法// 构造一个空的线性表Lint InitList（LinkList ＊L){/＊产生头结点L，并使L指向此头结点,头节点的数据域为空，不放数据的。
void ＊malloc(size_t)这里对返回值进行强制类型转换了,返回值是指向空类型的指针类型.＊/（＊L）= (LinkList）malloc（sizeof（struct LNode) ）;if( ！(＊L）)exit（0）；// 存储分配失败(＊L)-〉next = NULL；// 指针域为空return 1；}// 销毁线性表L,将包括头结点在内的所有元素释放其存储空间。
int DestroyList（LinkList ＊L）｛LinkList q;// 由于单链表的每一个元素是单独分配的，所以要一个一个的进行释放while（＊L )｛q = (*L)—〉next;free（＊L ）；//释放*L = q;}return 1；｝/*将L重置为空表,即将链表中除头结点外的所有元素释放其存储空间，但是将头结点指针域置空，这和销毁有区别哦。
不改变L，所以不需要用指针。
*/int ClearList( LinkList L )｛LinkList p，q；p = L—〉next；// p指向第一个结点while( p ) // 没到表尾则继续循环｛q = p—>next;free( p )；//释放空间p = q；}L—>next = NULL; // 头结点指针域为空,链表成了一个空表return 1;}// 若L为空表（根据头结点L—〉next来判断，为空则是空表)，则返回1，// 否则返回0.int ListEmpty(LinkList L）{if（L—>next ) // 非空return 0;elsereturn 1；｝// 返回L中数据元素个数。
单链表的 基本操作
单向链表单向链表的基本操作,创建一个由6个节点组成的单向链表，显示链表中每个节点的数据，并且做增加、删除、查找节点以及计算单链表的长度等处理。
➢需求分析：1.功能（1）用尾插法创建一带头结点的由6个节点组成的单向链表：从键盘读入一组整数，作为单链表中的元素，输入完第6个结点后结束;将创建好的单链表元素依次输出到屏幕上。
（2）显示链表中每个节点的数据（3）从键盘输入一个数,查找在以上创建的单链表中是否存在该数；如果存在,显示它的位置，即第几个元素;如果不存在，给出相应提示如“No found node!”。
（4）在上述的单链表中的指定位置插入指定数据，并输出单链表中所有数据。
(5）删除上述单链表中指定位置的结点，并输出单链表中所有数据。
(6）求单链表的长度并输出.2．输入要求先输入单链表中结点个数n,再输入单链表中所有数据，在单链表中需查找的数据，需插入的数据元素的位置、值，要删除的数据元素的位置。
3。
测试数据单链表中所有数据：12，23,56，21，8，10在单链表中需查找的数据：56；24插入的数据元素的位置、值：1，28；7,28；0，28要删除的数据元素的位置:6➢概要设计：1.算法思想：由于在操作过程中要进行插入、删除等操作，为运算方便，选用带头结点的单链表作数据元素的存储结构.对每个数据元素，由一个数据域和一个指针域组成，数据域放输入的数据值，指针域指向下一个结点。
2.数据结构：单链表结点类型:typedef struct Liistnode ｛int data；struct Listnode *next;｝NODE;3.模块划分：a)用尾插法建立带头结点的单链表＊CreateList函数；b)显示链表中每个结点的数据PrintList函数;c)从键盘输入一个数，查找单链表中是否存在该数FoundList函数；d)在单链表中指定位置插入指定数据并输出单链表中所有数据InsertList函数;e)删除单链表中指定位置的结点并输出单链表中所有数据DeleteList函数；f)计算单链表的长度并在屏幕上输出LengthList函数;g)主函数main()，功能是给出测试数据值，建立测试数据值的带头结点的单链表,调用PrintList函数、FoundList函数、InsertList函数、DeleteList函数、LengthList函数实现问题要求。
单链表的操作实现实验报告
题目来源：□√教材页题□√教师补充□自选题目
主要功能描述：链表的初始化、链表的创建（头部插入法、尾部插入法）、求表长、查找（按值查找、按序号查找）、插入、删除、输出、两个有序单链表的合并等。
设计分析：
初始化：为单链表申请头结点空间，将单链表设置为空；创建：（1）头部插入法：（a）初始化空表；（b）申请新结点并赋值；（c）插入新结点；（d）插入第i个元素。
break;
case'1':
puts("\n");
puts("*********************************************************");
puts("* 0---般创建1---头部插入法2---尾部插入法*");
puts("*********************************************************");
r->next=p;
r=p;
}
r->next=NULL;
return h;
}
/*头部插入*/
int CreatfromH(LinkList head)
{
LinkList p;
ElemType x;
puts("输入数据，输入-1000结束输入!");
while(1)
{
scanf("%d",&x);
if(x!=-1000)
while(p!=NULL)
{
printf("\n%d",p->data);
p=p->next;
实验二：单链表基本运算实现
{
int data; //存放表结点值
struct node *next; //存放表结点的直接后驱元素的地址
} ListNode,*LinkList;
//头插法创建初始链表
LinkList create_h(int size)
{
;//将工作指针p指向后一个结点
;//计数器累加
}
return i;
}
//打印链表中的现有元素
printList(LinkList head)
{
LinkList p;
;//将工作指针p指向第1个结点
{
p=(LinkList)malloc(sizeof(ListNode));//申请新结点的存储空间
scanf("%d",&p->data);//读入新结点的值到data域中
;//将新增结点插到头结点的后面
;//将新增结点插到头结点的后面
printf("————头插法建立链表(1)\n");
printf("————尾插法建立链表(2)\n");
printf("————按位查找元素(3)\n");
printf("————按值查找元素(4)\n");
printf("————插入元素(5)\n");
printf("————删除元素(6)\n");
printList(h);
break;
case 5:
printf("插入元素,请输入要插入元素的值:\n");
实验二 单链表基本操作
实验二单链表基本操作一实验目的1.学会定义单链表的结点类型，实现对单链表的一些基本操作和具体的函数定义，了解并掌握单链表的类定义以及成员函数的定义与调用。
2.掌握单链表基本操作及两个有序表归并、单链表逆置等操作的实现。
二实验要求1．预习C语言中结构体的定义与基本操作方法。
2．对单链表的每个基本操作用单独的函数实现。
3．编写完整程序完成下面的实验内容并上机运行。
4．整理并上交实验报告。
三实验内容1．编写程序完成单链表的下列基本操作：(1)初始化单链表La。
(2)在La中第i个元素之前插入一个新结点。
(3)删除La中的第i个元素结点。
(4)在La中查找某结点并返回其位置。
(5)打印输出La中的结点元素值。
2 .构造两个带有表头结点的有序单链表La、Lb，编写程序实现将La、Lb合并成一个有序单链表Lc。
合并思想是：程序需要3个指针：pa、pb、pc，其中pa，pb分别指向La表与Lb表中当前待比较插入的结点，pc 指向Lc表中当前最后一个结点。
依次扫描La和Lb中的元素，比较当前元素的值，将较小者链接到*pc 之后，如此重复直到La或Lb结束为止，再将另一个链表余下的内容链接到pc所指的结点之后。
3．构造一个单链表L，其头结点指针为head，编写程序实现将L逆置。
（即最后一个结点变成第一个结点，原来倒数第二个结点变成第二个结点，如此等等。
）四思考与提高1．如果上面实验内容2中合并的表内不允许有重复的数据该如何操作？2．如何将一个带头结点的单链表La分解成两个同样结构的单链表Lb，Lc，使得Lb中只含La表中奇数结点，Lc中含有La表的偶数结点？1．编写程序完成单链表的下列基本操作：(1)初始化单链表La。
(2)在La中第i个元素之前插入一个新结点。
(3)删除La中的第i个元素结点。
(4)在La中查找某结点并返回其位置。
(5)打印输出La中的结点元素值。
#include<stdio.h>#include<stdlib.h>#include <malloc.h>#define OK 1#define ERROR 0typedef int Status;typedef int ElemType;//定义存储结构typedef struct Lnode{int data; /*每个元素数据信息*/struct Lnode *next; /*存放后继元素的地址*/} LNode,*LinkList;int main(){void Create_L(LinkList &L,int n);void Print_L(LinkList L);Status ListInsert_L(LinkList &L,int i,ElemType e);Status ListDelete_L(LinkList &L,int i,ElemType &e);Status Find_L(LinkList L,int e);LinkList La;//创建单链表Laint n;printf("请输入链表La中的元素个数:\n");scanf("%d",&n);Create_L(La,n);//初始化单链表printf("现在La中的元素为:\n");Print_L(La);printf("-------------------------------------\n\n");printf("现在准备插入元素，请输入插入位置及所插入元素的值\n");int i,e;scanf("%d %d",&i,&e);ListInsert_L(La,i,e);printf("插入后La中的元素为:\n");Print_L(La);printf("-------------------------------------\n\n");printf("现在准备删除元素，请输入删除位置\n");scanf("%d",&i);ListDelete_L(La,i,e);printf("删除后La中的元素为:\n");Print_L(La);printf("-------------------------------------\n\n");printf("请输入所要查找元素的值:\n");scanf("%d",&e);Find_L(La,e);printf("所要查找元素的位置为:%d\n",Find_L(La,e)); }void Create_L(LinkList &L,int n){int j=1;L=(LinkList)malloc(sizeof(Lnode));L->next =NULL;//先建立一个带头结点的单链线性表L for(int i=n;i>0;--i){LinkList p=(LinkList)malloc(sizeof(Lnode));printf("请输入链表La中的第%d个元素:\n",j++);scanf("%d",&p->data);p->next=L->next;L->next =p;}//(逆序实现)/*LinkList q=L;for(int i=1;i<=n;i++){LinkList p=(LinkList)malloc (sizeof(Lnode));q->next=p;p->next=NULL;q=q->next ;printf("请输入链表La中的第%d个元素:\n",i);scanf("%d",&p->data);}//(正序实现)*/}//初始化单链表//输出单链表void Print_L(LinkList L){LinkList p;p=L->next;while(p){printf("%d ",p->data );p=p->next;}printf("\n");}//在单链表L的第i个位置前插入元素eStatus ListInsert_L(LinkList &L,int i,ElemType e) {LinkList p=L;int j=0;while(p&&j<i-1){p=p->next; ++j;}if(!p||j>i-1) return ERROR;LinkList s=(LinkList)malloc(sizeof(LNode));s->data=e; s->next=p->next;p->next=s;return OK;} //ListInsert_L//删除单链表L中第i个位置上的元素Status ListDelete_L(LinkList &L,int i,ElemType &e) {LinkList p=L;int j=0;while( p->next && j<i-1){p=p->next; ++j;}if(!p->next||j>i-1) return ERROR;LinkList q=p->next; p->next=q->next;e=q->data;free(q);return OK;}//LinkDelete_L/*查找元素并返回位置*/Status Find_L(LinkList L,int e){LinkList p=L->next;int j=1;while(p->data!=e&&p->next){p=p->next;j++;}if(p->data==e) return j;else{printf("无当前元素\n");return ERROR;}if(!p){printf("无当前元素\n");return ERROR;}}//定位2 .构造两个带有表头结点的有序单链表La、Lb，编写程序实现将La、Lb合并成一个有序单链表Lc。
c语言单链表的实现
c语言单链表的实现C语言单链表的实现单链表是一种常用的数据结构，它由一系列节点组成，每个节点包含数据和指向下一个节点的指针。
在C语言中，我们可以通过定义结构体和指针来实现单链表的操作。
我们需要定义一个节点的结构体，该结构体包含数据和指向下一个节点的指针。
假设我们需要实现一个存储整数的单链表，可以定义如下结构体：```cstruct Node {int data;struct Node* next;};```接下来，我们可以定义一些基本的操作函数，例如创建链表、插入节点、删除节点、查找节点等。
下面我们逐一介绍这些操作函数的实现方法。
1. 创建链表创建链表需要分配内存，并设置头节点的指针为空。
代码如下：```cstruct Node* createList() {struct Node* head = (struct Node*)malloc(sizeof(struct Node));head->next = NULL;return head;}```2. 插入节点插入节点需要找到要插入位置的前一个节点，然后进行插入操作。
代码如下：```cvoid insertNode(struct Node* head, int data, int position) {struct Node* newNode = (struct Node*)malloc(sizeof(struct Node));newNode->data = data;struct Node* temp = head;for (int i = 0; i < position - 1; i++) {temp = temp->next;}newNode->next = temp->next;temp->next = newNode;}```3. 删除节点删除节点需要找到要删除节点的前一个节点，然后进行删除操作。
数据结构c语言版上机报告单链表
数据结构C语言版上机报告：单链表序在数据结构课程中，单链表是一个重要的概念，也是C语言中常用的数据结构之一。
本次报告将深入探讨单链表的基本概念、操作方法以及应用场景，帮助读者更深入地理解和掌握这一数据结构。
一、概述1.1 单链表的定义单链表是一种线性表，它由一系列节点组成，每个节点包含两部分：数据域和指针域。
数据域用于存储数据元素，指针域用于指向下一个节点，通过指针将这些节点串联在一起，形成一个链表结构。
1.2 单链表的特点单链表具有以下特点：（1）动态性：单链表的长度可以动态地增加或减少，不需要预先分配固定大小的空间。
（2）插入和删除操作高效：在单链表中进行插入和删除操作时，只需要修改指针的指向，时间复杂度为O(1)。
（3）随机访问效率低：由于单链表采用链式存储结构，无法通过下标直接访问元素，需要从头节点开始依次遍历，时间复杂度为O(n)。
1.3 单链表的基本操作单链表的基本操作包括：创建、插入、删除、查找等。
这些操作是使用单链表时常常会涉及到的，下面将逐一介绍这些操作的具体实现方法和应用场景。
二、创建2.1 头插法和尾插法在C语言中，可以通过头插法和尾插法来创建单链表。
头插法是将新节点插入到链表的头部，尾插法是将新节点插入到链表的尾部，这两种方法各有优缺点，可以根据具体应用场景来选择。
2.2 应用场景头插法适合于链表的逆序建立，尾插法适合于链表的顺序建立。
三、插入3.1 在指定位置插入节点在单链表中，插入节点需要考虑两种情况：在链表头部插入和在链表中间插入。
通过对指针的操作，可以实现在指定位置插入节点的功能。
3.2 应用场景在实际应用中，经常会有需要在指定位置插入节点的情况，比如排序操作、合并两个有序链表等。
四、删除4.1 删除指定节点在单链表中，删除节点同样需要考虑两种情况：删除头节点和删除中间节点。
通过对指针的操作，可以实现删除指定节点的功能。
4.2 应用场景在实际应用中，经常会有需要删除指定节点的情况，比如删除链表中特定数值的节点等。
C语言单链表基本函数.docx
•无空间限制带头结点单链表结构体1. 宏定义：#include<stdio.h>#include<stdlib.h>#define OVERFLOW -2#dcfinc OK 1#define TRUE 1#define ERROR 0#define FALSE 0#define ElemType ****；2. 结构体：2. 无空间限制单链表结构休：typedef struct Node{ElemType data; struct Node *next;}Node,*Linklist;3. 基本函数：int Initlist_Linklist_l(Linklist L)/*初始化单链表：1 •先决条件：定义一个全局尾指针变量；2•函数作用：初始化链表。
*/ {L->next=NULL;tail=L;printfC*单链表现初始化了!\n“)；return OK;}int Initlist_Linklist_2(Linklist L)/*初始化单链表：1 •先决条件：初始化结构体数据即L->next=NULL(-次咸执行一次Initlist_Linklist_l,定义一个全局尾指针变量；2•函数作用：删除已有链表，并初始化单链表*/ {Node *p,*q;if(p=L->next)while(p)q=p->ncxt; free(p); p=q；L->next=NULL;tail=L;printfC单链表现初始化了!\n“);return OK;}int Increase_LinkIist(Linklist L)/*尾接法增加数据•先决条件：先按初始化函数初始化，定义一个全局尾指针变量; 2•函数作用：为单链表L增加数据，以标识符“0”结束*/{int panduan;ElemType e;Node *p;printf(”输入0结束增加数据!\n“);doprintfC*请输入数据:”);scanf(”％d",&e);〃因ElemType不同而不同，特别是字符类型getchar();if(c==0)//M ElemType不同而不同，特别是字符类型{printf(“再次输入0表示结束增加数据,输入非零将把0增加到数据中An“);printf(”请输入:”);scanf("%d",&panduan);getchar();if(panduan==0){printf( ”正常结束增加数据!\rT);return OK;}}p=(Nodc *)malloc(sizeof(Node));if(p==NULL){printf(M屮请空间失败，请稍后再试!\n");return OVERFLOW;}tail->next=p;tail=p;tail->data=e;tail->next=NULL;e++;}while(e!=O);//因ElemType不同而不同，特别是字符类型printf(”正常结束增加数据!\n“);retum OK;}int Input_Linklist(Linklist L)/*遍历输出函数:1 •先决条件：先决条件：先按初始化函数初始化，使链表为带头结点;2•函数作用：输岀单链表中各个数据*/{Node *p;int count=0;for(p=L->next;p!=NULL;p=p->next){printf(”％d *\p->data);//会因ElemType 不同而不同coun t++;if(count%10==0)printf(M\n M);}printf(” \n”);return OK;}int Delete_Linklist_l(Linklist L)/*删除函数:1 •先决条件：初始化单链表或初始化结构体数据即L->next=NULL, 单链表以值(要求为数，不能是字符)排列,定义一个全局尾指针变量；2•函数作用：删除表中所不大于maxk且不小于mink的元素。
c语言单链表基本操作
c语言单链表基本操作
5. 查找节点：
```c struct Node* searchNode(struct Node* head, int data) {
c语言单链表基本操作
4. 删除节点：
```c void deleteNode(struct Node** head, int data) {
struct Node* currentNode = *head; struct Node* prevNode = NULL;
// 遍历链表，找到要删除的节点 while (currentNode != NULL && currentNode->data != data) {
c语言单链表基本操作
这些是单链表的基本操作，可以根据需要进行调用和组合，实现对链表的创建、插入、删 除、查找和打印等操作。需要注意的是，在使用完链表后，要记得释放节点所占用的内存， 避免内存泄漏。
struct Node* currentNode = head; while (currentNode != NULL && currentNode->data != data) {
currentNode = currentNode->next; } return currentNode; // 返回找到的节点（如果找到） } ```
c语言单链表基本操作
2. 创建链表： ```c struct Node* createLinkedList() {
return NULL; // 返回一个空链表 }
单链表的实现及其基本操作
单链表的实现及其基本操作结点的引⼊链表是⼀种链式存储结构，链式存储结构的特点是⽤⼀组任意的存储单元存储数据元素。
为了能正确表⽰数据元素之间的线性关系，需引⼊结点概念。
⼀个结点表⽰链表中的⼀个数据元素，节点中除了储存数据元素的信息，还必须存放指向下⼀个节点的的指针（单、双链表的最后⼀个节点除外，它们存储的是⼀个空指针NULL）结点的结构如下图所⽰：代码如下：1 typedef struct node{2int data;3struct node* pNext;4 }Node, *PNode;View Code注：这⾥假设结点中储存的是整型 (int) 的数据单链表由多个结点依次连接⽽成，我们不难想象出它结构：我们注意到：在第⼀个结点的前⾯多了⼀个头结点，这是为了处理空表的⽅便⽽引⼊的，它的指针指向链表的第⼀个结点，⽽它的data域不存放任何信息。
单链表的基本操作1.创建链表1 PNode createList()2 {3int len, value;45 PNode pHead = (PNode)(malloc(sizeof(Node)));6 PNode pTail = pHead;7 pTail->pNext = NULL;89 printf("请输⼊你要的节点个数：");10 scanf("%d", &len);11for(int i=1;i<=len;i++){12 printf("请输⼊第%d个节点的值：", i);13 scanf("%d", &value);1415 PNode pNew = (PNode)malloc(sizeof(Node));16 pNew->data = value;17 pTail->pNext = pNew;18 pTail = pNew;19 pTail->pNext = NULL;20 }2122return pHead;23 }View Code2.遍历链表void traverse(PNode pHead){printf("遍历结果为:\n");PNode pTra = pHead;while(pTra->pNext != NULL){printf("%d ", pTra->pNext->data);pTra = pTra->pNext;}printf("\n");}View Code3.判断链表是否为空1bool isEmpty(PNode pHead)2 {3if(pHead->pNext==NULL)4return true;5else6return false;7 }View Code4.链表长度1int length(PNode pHead)2 {3int len = 0;4while(pHead->pNext!=NULL){5 pHead = pHead->pNext;6 len++;7 }8return len;910 }View Code5.插⼊结点1bool insert(PNode pHead, int pos, int val)2 {3if(pos<1 || pos>length(pHead)){4return false;5 }else{6 PNode pInsert = pHead;7for(int i=1;i<pos;i++){8 pInsert = pInsert->pNext;9 }1011 PNode pNew = (PNode)malloc(sizeof(Node));12 pNew->data = val;13 pNew->pNext = pInsert->pNext;14 pInsert->pNext = pNew;1516return true;17 }1819 }View Code6.删除结点1bool del(PNode pHead, int pos)2 {3if(pos<1 || pos>length(pHead)){4return false;5 }else{6 PNode pDel = pHead;7for(int i=1;i<pos;i++){8 pDel = pDel->pNext;9 }1011if(pos==length(pHead)){12free(pDel->pNext);13 pDel->pNext = NULL;14 }else{15 PNode pNext = pDel->pNext->pNext;16free(pDel->pNext);17 pDel->pNext = pNext;18 }1920return true;2122 }232425 }View Code7.查找节点（1）按元素值查找1 PNode locate(PNode pHead, int value)2 {3 PNode p = pHead->pNext;4while(p&&p->data!=value){ //NULL 是 05 p = p->pNext;6 }7return p;8 }View Code（2）按序号查找1 PNode get(PNode pHead, int k)2 {3 PNode p = pHead;4for(int i=1;i<=k;i++){5 p = p->pNext;6 }7return p;89 }View Code完整代码1 #include<stdio.h>2 #include<stdlib.h>3 typedef struct node{4int data;5struct node* pNext;6 }Node, *PNode;78 PNode createList();9void traverse(PNode pHead);10bool isEmpty(PNode pHead);11int length(PNode pHead);12bool insert(PNode pHead, int pos, int val);13bool del(PNode pHead, int pos);14 PNode get(PNode pHead, int k); //按序号查找15 PNode locate(PNode pHead, int value);//按值查找 1617int main(void)18 {19//test2021return0;22 }2324 PNode createList()25 {26int len, value;2728 PNode pHead = (PNode)(malloc(sizeof(Node)));29 PNode pTail = pHead;30 pTail->pNext = NULL;3132 printf("请输⼊你要的节点个数：");33 scanf("%d", &len);34for(int i=1;i<=len;i++){35 printf("请输⼊第%d个节点的值：", i);36 scanf("%d", &value);3738 PNode pNew = (PNode)malloc(sizeof(Node));39 pNew->data = value;40 pTail->pNext = pNew;41 pTail = pNew;42 pTail->pNext = NULL;43 }4445return pHead;46 }474849void traverse(PNode pHead)50 {51 printf("遍历结果为:\n");52 PNode pTra = pHead;53while(pTra->pNext != NULL)54 {55 printf("%d ", pTra->pNext->data);56 pTra = pTra->pNext;57 }58 printf("\n");59 }6061bool isEmpty(PNode pHead)62 {63if(pHead->pNext==NULL)64return true;65else66return false;67 }6869int length(PNode pHead)70 {71int len = 0;72while(pHead->pNext!=NULL){73 pHead = pHead->pNext;74 len++;75 }76return len;7778 }7980bool insert(PNode pHead, int pos, int val)81 {82if(pos<1 || pos>length(pHead)){83return false;84 }else{85 PNode pInsert = pHead;86for(int i=1;i<pos;i++){87 pInsert = pInsert->pNext;88 }8990 PNode pNew = (PNode)malloc(sizeof(Node));91 pNew->data = val;92 pNew->pNext = pInsert->pNext;93 pInsert->pNext = pNew;9495return true;96 }9798 }99100bool del(PNode pHead, int pos)101 {102if(pos<1 || pos>length(pHead)){103return false;104 }else{105 PNode pDel = pHead;106for(int i=1;i<pos;i++){107 pDel = pDel->pNext;108 }109110if(pos==length(pHead)){111free(pDel->pNext);112 pDel->pNext = NULL;113 }else{114 PNode pNext = pDel->pNext->pNext;115free(pDel->pNext);116 pDel->pNext = pNext;117 }118119return true;120121 }122123124 }125126 PNode get(PNode pHead, int k)127 {128 PNode p = pHead;129for(int i=1;i<=k;i++){130 p = p->pNext;131 }132return p;133134 }135 PNode locate(PNode pHead, int value)136 {137 PNode p = pHead->pNext;138while(p&&p->data!=value){ //NULL 是 0 139 p = p->pNext;140 }141return p;142 }View Code。
单链表创建、删除、查找、插入之C语言实现
单链表创建、删除、查找、插⼊之C语⾔实现本⽂将详细的介绍C语⾔单链表的创建、删除、查找、插⼊以及输出功能⼀、创建#include<stdio.h>#include<stdlib.h>typedef int ElemType;/*结构体部分*/typedef struct Node{ElemType data; //数值域struct Node *next; //指针域}Linklist;Linklist *InitList(Linklist *L) //初始化单链表{L = (Linklist *) malloc(sizeof(Linklist));L->next = NULL;return L;}Linklist *CreateList(int n){/*通过输⼊n个数据，创建⼀个单链表*/int x,i;Linklist *L,*r,*p;L = InitList(L); //构造头结点r = L;printf("input %d value: ",n);for(i=0;i<n;i++){scanf("%d",&x);p = (Linklist *)malloc(sizeof(Linklist));p -> data = x;p -> next = NULL;r->next = p;r = r->next; //指针r始终指向链表中末数据元素所在位置}return L;}⼆、插⼊int InsItem1(Linklist *L,ElemType item,int x) /*给定的序号来插⼊*/{int i = 1;Linklist *p,*t;p = L;t = (Linklist *)malloc(sizeof(Linklist));t ->data = item;if(L->next==NULL){ /*若L为空表且要求将新结点插⼊到第0个位置*/if(x==1){L->next=t;t->next=NULL;return1;}/*若L为空表且要求将新结点插⼊到第⾮0个位置，则操作失败*/else{printf("wrong!\n");return0;}}while(p->next!=NULL&&i<x)/*查找第i个节点*/{p = p->next;i++;}if(p->next==NULL&&i<x)/*在表中不存在插⼊位置i ，找不到，则插⼊操作失败*/{printf("The node %d is not exist\n",x);return0;}elset->next = p->next;p->next = t;return1;}}int InsItem2(Linklist *L,ElemType item,ElemType k) /*插⼊给定值在链表中的位置*/ {Linklist *q,*p,*t;t = (Linklist *)malloc(sizeof(Linklist));t->data = item;if(L->next==NULL){printf("The linklist is empty\n");return0;}else{q = L;p = L->next;while(p->next!=NULL)/*查找值为k的结点*/{if(p->data!=k){q = p;p = p->next;}elsebreak;}if(p==NULL)/*如p= =NULL，则没有值为k的结点，插⼊操作失败*/{printf("The node %d is not exist\n",k);return0;}else{q->next = t;t->next = p;return1;}}}三、删除int DelItem(Linklist *L,int x)//在单链表中删除数据元素{int i = 1;Linklist *p,*q;p = L;if(L->next==NULL) /*L为空表，⽆结点可删除*/{printf("The linklist is empty!\n");return0;}while(p->next!=NULL&&i<x){p = p->next;i++;}if(p->next==NULL)/*若没有第i个结点，则删除操作失败*/{printf("The node %d is not exist\n",x);return0;}else{q = p->next;p->next = p->next->next;free(q);return1;}}四、查找int LocItem(Linklist *L,ElemType x)//查找给定值的结点位置Linklist *p,*q,*r;int i = 1;if(L->next==NULL){printf("The linklist is empty\n");return0;}else{p = L->next;while(p!=NULL){if(p->data!=x){i++;p = p->next;}elsebreak;}if(p==NULL)/*如p= =NULL，则没有值为item的结点，删除操作失败*/ {printf("The node %d is not exist\n",x);return0;}/*若找到该节点返回该节点的位置*/elsereturn i;}}五、输出void output(Linklist *L) //输出{Linklist *p;p = L->next;printf("output element: \n");for(;p!=NULL;p=p->next){printf(" %d ",p->data);}printf("\n");}六、主函数部分int main(){ElemType x = 5;Linklist *L;L = CreateList(x);output(L);InsItem1(L,3,2);output(L);InsItem1(L,3,4);output(L);DelItem(L,3);output(L);printf("3的位置是: %d",LocItem(L,3));}。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
{
printf("%s\t\t%s\n",p->stu_id,p->stu_name); ///这里为了简单只输出学生姓名和学号
p=p->next;
}
}
///从控制台获取一个节点
pStu get_node(void)
{
pStu N = (pStu)malloc(sizeof(Stu));
{
p->next=q->next;
break;
}
p=q;
q=q->next;
}
if(!q)
{
printf("未找到相应节点！\n");
}
else
{
free(q);///释放内存
printf("学生信息已删除！\n");
{
char stu_name[15],stu_id[10];
float score[2][5];
int term,class_
struct student *next;
}Stu,*pStu;
///创建一个单链表,即建立一个链表头，头占内存，但不存学生信息
void create_link(pStu *S)
/*
* 功能：单链表的基本操作——C语言
*
* 作者：深度网络社团.Robothy
*
* 时间：2015年9月14日
*/
#include "stdio.h"
#include "stdlib.h"
#include "string.h"
///结构体变量，表示一个学生的所有属性
typedef struct student
pStu q=p->next;
while(q)
{
free(p);
p=q;
q=q->next;
}
free(p);
}
int main(void)
{
pStu S; ///声明一个链表
create_link(&S); ///创建一个链表，即分配头指针的内存
}
}
///打印整个链表，也就是对整个链表进行遍历，修改链表中的节点算法类似，注意这里的形式参数传的是一级指针。
void print_link(Stu *S)
{
pStu p=S->next; ///创建链表的时候头部没有存学生数据，所以要从链表的第二个节点开始
printf("\n\n学号\t\t姓名\n------------------------\n");
pStu N; ///声明一个指向节点的变量
int i=0;
for(;i<3;i++) ///连续插入 i 个节点
{
N = get_node();
insert_node(&S,&N);
}
print_link(S); ///打印整个链表
delete_node(&S,"123"); ///删除学号或姓名为123的学生
print_link(S); ///再次打印链表
free_link(&S);
return 0;
}
printf("请输入学号和姓名：\n");
scanf("%s%s",&(N->stu_id),&(N->stu_name));
N->next=NULL;
return N;
}
///释放整个链表的内存,结束程序的时候使用
void free_link(pStu *S)
{
pStu p=(*S);
{
(*S)=(pStu)malloc(sizeof(Stu));
(*S)->next=NULL;
}
///往链表中插入一个节点，头部插入，注意形式参数用的是二级指针
void insert_node(pStu *S,pStu *node)
{
(*node)->next=(*S)->next;
(*S)->next=*node;
}
///往链表中删除一个节点,按照学号或姓名删除，一次只删除一个
void delete_node(pStu *S,char *msg)
{
pStu p=*S;
pStu q=p->next;
while(q)
{
if(!(strcmp(msg,q->stu_id))||!(strcmp(msg,q->stu_name)))///找到节点