链表（单向链表）

已于 2024-01-25 09:52:49 修改
阅读量337 收藏 6
点赞数 8
文章标签： 排序算法 算法
于 2024-01-24 22:30:26 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_81513928/article/details/135829467
版权

单向链表所有操作：

head.h:

  1 #ifndef __HEAD_H__
  2 #define __HEAD_H__
  3 #include<stdio.h>
  4 #include<string.h>
  5 #include<stdlib.h>
  6 enum num
  7 {
  8     FALSE=-1,
  9     SUCCESS
 10 };
 11 typedef int datatype;
 12 //定义节点结构体
 13 typedef struct Node
 14 {
 15     //数据域
 16     datatype data;
 17     //指针域
 18     struct Node *next;
 19 }*Linklist;
 20 Linklist create();
 21 Linklist insert_head(Linklist head,datatype element);
 22 void output(Linklist head);
 23 Linklist insert_rear(Linklist head,datatype element);
 24 Linklist delete_head(Linklist head);
 25 Linklist delete_rear(Linklist head);
 26 int length(Linklist head);
 27 Linklist insert_pos(Linklist head,datatype element,int pos);
 28 Linklist delete_pos(Linklist head,int pos);
 29 void search_pos(Linklist head,int pos);
 30 void change_pos(Linklist head,int pos,datatype element);
 31 Linklist rev(Linklist head);
 32 void search_down(Linklist head,int m);
 33 int search_key(Linklist head,datatype key);
 34 Linklist change_key(Linklist head,datatype key,datatype element);
 35 Linklist delete_key(Linklist head,datatype key);
 36 void Bubble(Linklist head);
 37 void simple_sort(Linklist head);
 38 Linklist free_space(Linklist head);
 39 #endif

main.c：

  1 #include "head.h"
  2 int main(int argc, const char *argv[])
  3 {
  4     Linklist head=NULL;//定义单链表的头指针
  5     int n;
  6     datatype element;//插入值
  7     printf("please enter n:");
  8     scanf("%d",&n);
  9 /*  for(int i=0;i<n;i++)
 10     {
 11         printf("please enter %d element:",i+1);
 12         scanf("%d",&element);
 13         head=insert_head(head,element);//头插
 14     }
 15     //遍历
 16     output(head);*/
 17     for(int i=0;i<n;i++)
 18     {
 19         printf("please enter %d element:",i+1);
 20         scanf("%d",&element);
 21         head=insert_rear(head,element);//尾插
 22     }
 23     output(head);
 24 /*  //头删
 25     head=delete_head(head);
 26     output(head);
 27     //尾删
 28     head=delete_rear(head);
 29     output(head);
 30     //按位置插入*/
 31     int pos;/*
 32     printf("please eneter insert_pos:");
 33     scanf("%d",&pos);
 34     printf("please enter insert_pos element:");
 35     scanf("%d",&element);
 36     head=insert_pos(head,element,pos);
 37     output(head);
 38     //任意位置删除
 39     printf("please eneter delete_pos:");
 40     scanf("%d",&pos);
 41     head=delete_pos(head,pos);
 42     output(head); 
 43     //任意位置查找
 44     printf("please eneter search_pos:");
 45     scanf("%d",&pos);
 46     search_pos(head,pos);
 47     //任意位置修改
 48     printf("please eneter change_pos:");
 49     scanf("%d",&pos);
 50     printf("please eneter change_element:");
 51     scanf("%d",&element);
 52     change_pos(head,pos,element);
 53     output(head);*/
 54     //逆置
 55 /*  head=rev(head);
 56     output(head);
 57     //查找倒第n个
 58     int m;
 59     printf("please enter search_down m:");
 60     scanf("%d",&m);
 61     search_down(head,m);i*/
 62     //按任意元素查找
 63     datatype key;
 64 /*  printf("please enter search_key:");
 65     scanf("%d",&key);
 66     pos=search_key(head,key);
 67     if(pos==-1)
 68         printf("erro:%d\n",pos);
 69     else
 70         printf("search by key pos:%d\n",pos);*/
 71     //按任意元素修改
 72 /*  printf("please enter change key:");
 73     scanf("%d",&key);
 74     printf("please enter change_key element:");
 75     scanf("%d",&element);
 76     head=change_key(head,key,element);
 77     output(head);
 78     //按任意元素删除
 79     printf("please enter delete_key:");
 80     scanf("%d",&key);
 81     head=delete_key(head,key);
 82     output(head);*/
 83     //排序
 84     //1.冒泡
 85 /*  Bubble(head);
 86     output(head);*/
 87     //2.简单
 88     simple_sort(head);
 89     output(head);
 90     //释放
 91     head=free_space(head);
 92     output(head);
 93     return 0;
 94 }
 95

test.c：

  1 #include "head.h"
  2 Linklist create()//创建新节点
  3 {
  4     Linklist s=(Linklist)malloc(sizeof(struct Node));
  5     if(NULL==s)
  6         return NULL;
  7     //成功初始化
  8     s->data=0;
  9     s->next=NULL;
 10     return s;
 11 }
 12 //头插
 13 Linklist insert_head(Linklist head,datatype element)
 14 {
 15     //创建新节点s
 16     Linklist s=create();
 17     s->data=element;
 18     //判断链表是否为空
 19     if(NULL==head)
 20     {
 21         head=s;
 22     }
 23     else
 24     {
 25         s->next=head;
 26         head=s;
 27     }
 28     return head;
 29 }
 30 //遍历
 31 void output(Linklist head)
 32 {
 33     if(NULL==head)
 34     {
 35         puts("empty");
 36         return;
 37     }
 38     Linklist p=head;
 39     while(p!=NULL)
 40     {
 41         printf("%-4d",p->data);                                                                                                                         
 42         p=p->next;
 43     }
 44     puts("");
 45 }
 46 //尾插
 47 Linklist insert_rear(Linklist head,datatype element)
 48 {
 49     Linklist s=create();
 50     s->data=element;
 51     //判断链表是否为空
 52     if(NULL==head)
 53         head=s;
 54     else
 55     {
 56         Linklist p=head;
 57         while(p->next!=NULL)
 58         {
 59             p=p->next;
 60         }
 61         p->next=s;
 62     }
 63     return head;
 64 }
 65 //头删
 66 Linklist delete_head(Linklist head)
 67 {
 68     if(NULL==head)
 69         return head;
 70     else
 71     {
 72         Linklist del=head;
 73         head=head->next;
 74         free(del);
 75         del=NULL;
 76     }
 77     return head;
 78 }
 79 //尾删
 80 Linklist delete_rear(Linklist head)
 81 {
 82     if(NULL==head)
 83     {
 84         puts("empty");
 85         return head;
 86     }
 87     else if(NULL==head->next)                                                                                                                           
 88     {
 89         free(head);
 90         head=NULL;
 91         return head;
 92     }
 93     else
 94     {
 95         Linklist del=head;
 96         while(del->next->next!=NULL)
 97         {                                                                                                                                               
 98             del=del->next;
 99         }
100         free(del->next);
101         del->next=NULL;
102         return head;
103     }
104 }
105 //计算链表长度
106 int length(Linklist head)
107 {
108     Linklist p=head;
109     int len=0;
110     while(p)
111     {
112         len++;
113         p=p->next;
114     }
115     return len;
116 }
117 //按位置插入
118 Linklist insert_pos(Linklist head,datatype element,int pos)
119 {
120     if(pos<1 || pos>length(head)+1)
121     {
122         puts("erro");
123         return head;
124     }
125     Linklist s=create();
126     s->data=element;
127     if(pos==1)
128     {
129         head=insert_head(head,element);
130         return head;
131     }
132     Linklist p=head;
133     for(int i=1;i<pos-1;i++)
134         p=p->next;
135     s->next=p->next;
136     p->next=s;
137     return head;
138 }
139 //按任意位置删除
140 Linklist delete_pos(Linklist head,int pos)
141 {
142     if(pos<1||pos>length(head)|| NULL==head)                                                                                                            
143         return head;
144     if(pos==1)
145     {
146         head=delete_head(head);
147         return head;
148     }
149     Linklist p=head;
150     for(int i=1;i<pos-1;i++)
151         p=p->next;
152     Linklist del=p->next;
153     p->next=del->next;
154     free(del);del=NULL;
155     return head;
156 }
157 //任意位置查找
158 void search_pos(Linklist head,int pos)
159 {
160     if(pos<1||pos>length(head)||NULL==head)
161         puts("erro");
162     Linklist p=head;
163     for(int i=1;i<pos;i++)
164         p=p->next;
165     printf("search by pos: %d\n",p->data);
166 }
167 //任意位置修改
168 void change_pos(Linklist head,int pos,datatype element)
169 {
170     if(pos<1||pos>length(head)||NULL==head)
171         puts("erro");
172     Linklist p=head;
173     for(int i=1;i<pos;i++)
174         p=p->next;
175     p->data=element;
176 }
177 //逆置
178 Linklist rev(Linklist head)
179 {
180     if(NULL==head)
181         return NULL;
182     Linklist p=head->next;
183     head->next=NULL;
184     while(p!=NULL)
185     {
186         Linklist t=p;
187         p=p->next;                                                                                                                                      
188         t->next=head;
189         head=t;
190     }
191     return head;
192 }
193 //查找倒第n个
194 void search_down(Linklist head,int m)
195 {
196     if(NULL==head||m<0||m>length(head))
197         return;
198     Linklist p=head,q=head;
199     for(int i=0;i<m;i++)
200     {
201         p=p->next;
202     }
203     while(p!=NULL)
204     {
205         p=p->next;
206         q=q->next;
207     }
208     printf("search by down:%d\n",q->data);
209 }
210 //按任意元素查找
211 int search_key(Linklist head,datatype key)
212 {
213     if(NULL==head)
214         return FALSE;
215     Linklist p=head;
216     int index=0;
217     while(p!=NULL)
218     {
219         index++;
220         if(p->data==key)
221             return index;
222         p=p->next;
223     }
224     return FALSE;
225 }
226 //按任意元素修改
227 Linklist change_key(Linklist head,datatype key,datatype element)
228 {
229     int pos=search_key(head,key);
230     if(pos==FALSE)
231     {
232         puts("erro");                                                                                                                                   
233         return head;
234     }
235     change_pos(head,pos,element);
236     return head;//可以不返，动的值而不是头
237 }
238 //按任意元素删除
239 Linklist delete_key(Linklist head,datatype key)
240 {
241     int pos=search_key(head,key);
242     if(pos==FALSE)
243     {
244         puts("erro");
245         return head;
246     }
247     head=delete_pos(head,pos);
248     return head;
249 }
250 //排序
251 //1.冒泡
252 void Bubble(Linklist head)
253 {
254     if(head==NULL)
255         return;
256     int len=length(head);
257     for(int i=1;i<len;i++)
258     {
259         Linklist p=head;
260         for(int j=0;j<len-i;j++)
261         {
262             if(p->data>p->next->data)
263             {
264                 datatype t=p->data;
265                 p->data=p->next->data;
266                 p->next->data=t;
267             }
268             p=p->next;
269         }
270     }
271 }
272 //2.简单
273 void simple_sort(Linklist head)
274 {
275     if(head==NULL)
276         return;
277     Linklist i=head;                                                                                                                                    
278     while(i->next!=NULL)
279     {
280         Linklist min=i;
281         Linklist j=i->next;
282         while(j!=NULL)
283         {
284             if(min->data>j->data)
285                 min=j;
286             j=j->next;
287         }
288         if(min!=i)
289         {
290             datatype t=min->data;
291             min->data=i->data;
292             i->data=t;
293         }
294         i=i->next;
295     }
296 }
297 void simple_sort(Linklist head)
298 {
299     if(head==NULL)
300         return;
301     for(Linklist i=head;i->next!=NULL;i=i->next)
302     {
303         Linklist min=i;
304         for(Linklist j=i->next;j!=NULL;j=j->next)
305         {
306             if(min->data>j->data)
307             {
308                 min=j;
309             }
310         }
311         if(min!=i)
312         {
313             datatype t=min->data;
314             min->data=i->data;
315             i->data=t;
316         }
317     }
318 
319 }
320 //释放
321 Linklist free_space(Linklist head)
322 {                                                                                                                                                       
323     if(NULL==head)
324         return head;
325     while(head!=NULL)
326     {
327         head=delete_head(head);
328     }
329     head=NULL;//默认就为NULL
330     return head;
331 }

1.按任意元素查找

 2.按任意元素修改

3.按任意元素删除

 

 4.排序

冒泡排序：

简单排序：

5.释放

流程图：

紫枫、苏
关注
  • 8
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
C语言链表操作详解
qq_41481924的博客
12-29 14万+
为什么要使用链表 在未学习链表时，我们常用的存储数据的方式无非就是数组。使用数组存储数据的好处就是查询快，但是它的弊端也很明显： 使用前需声明数组的长度，一旦声明长度就不能更改 插入和删除操作需要移动大量的数组元素，效率慢 只能存储一种类型的数据. 而链表则可以实现以上这些数组所不具备的功能，此时引入了结构体来实现创建链表的操作。 链表的特点： n个节点离散分配 每一个节...
C 单向链表排序
weixin_54194530的博客
09-06 2573
链表排序链表排序的两种方式一、交换结点的数据域二、断开链表，重新形成方法示例 链表排序的两种方式 一、交换结点的数据域 有很多种方法，比如冒泡排序，选择排序等其他排序方法 struct Node *link_sort(struct Node *head) { int value; struct Node *p = head; struct Node *q = NULL; while(p) { q = p->next; while(q) { if(p->data &g
C语言链表超详解
热门推荐
k666499436的博客
05-17 10万+
详细对比顺序表与链表的区别， 实现单链表，与双向带头循环链表，以及各中类型的链表
单向循环链表
jxc47的博客
09-20 1112
既然有线性表的链式存储结构，那么我们可以想到一定也有单向循环链表。 下面让我们来看看单向循环链表。 单向循环链表的本质就是让单链表的尾节点指针指向头结点，这样就可以让整个单链表形成一个环。 这种头尾相连的单链表就叫做单向循环链表。 为了方便操作，我们让头指针不再指向虚拟头结点，而是直接指向真实头结点，也就是链表中的第一个节点。 此时单向循环链表因为存储结构的改变所以不能再用LinkedList ...
Java实现单向链表
weixin_50394543的博客
03-16 3461
Java实现单向链表
单向链表SingleLinkedList
weixin_66598341的博客
09-09 1017
本文案例仅仅使用Java语言实现单向链表的一些简单的增删改查，完成反转单向链表，以及借助栈逆序遍历单向链表等功能。
单向链表Python
泰敢人辣的博客
07-26 3580
链表是一种常见的数据结构，用于存储和组织数据。它由一系列节点组成，每个节点包含数据和指向下一个节点的指针。 链表相对于数组的优势在于灵活性。由于链表的节点并不一定连续存储在内存中，因此可以动态地插入和删除节点，而不需要移动其他节点。然而，链表的缺点是访问特定位置的节点较慢，需要从头节点开始遍历到指定位置。
单向、双向链表
大树
12-08 2750
链表 一、介绍 1、介绍 ​ 链表是一种非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。链表由一系列节点（链表中每一个元素称为节点）组成，节点可以在运行时动态生成。每个节点包括两个部分：一个是存储数据元素的数据域，另一个是存储下一个节点地址的指针域 （1）单向链表(单链表)是链表的一种，它由节点组成，每个节点都包含下一个节点的指针 （2）双向链表(双链表)是链表的一种。和单链表一样，双链表也是由节点组成，它的每个数据节点中都有两个指针，分别指向直接后继和直接前驱。所以，从双向链
单向链表——C语言
Ctrl_C_V_is_easy的博客
08-21 1476
链表相较于顺序表来说有很多优点，尤其是表中间插入和表头插入操作更简单，时间复杂度更低，而且空间利用率更高。单链表从表头开始，每个节点之间用指针来链接，最后一个节点的指针指向NULL，所以链表所用的计算机内存不一定是连续的，而每个节点都由数据域和指针域构成。
单向链表中间节点
bdmh的专栏
04-30 963
求单向链表中间的节点值，如果奇数个节点取中间，偶数个取偏右边的那个值。
C++实现简单单向链表
12-17
本文实例为大家分享了C++实现简单单向链表的具体代码，供大家参考，具体内容如下 为了练习一下对链表的理解，尝试手动造轮子，实现单向链表的右添加，左添加和删除的功能。 头文件 #pragma once #include using ...
Java实现单向链表反转
08-27
主要为大家详细介绍了Java实现单向链表反转，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
单向循环链表python
07-26
单向循环链表（Singly Circular Linked List）是一种特殊的链表，它与普通的单向链表非常相似，唯一的区别在于尾节点的next指针指向头节点而不是空。这样就形成了一个循环，使得链表中的节点可以通过循环遍历而不会...
单链表实现双向循环链表_链表_
09-29
单链表实现双向循环链表单向链表存在一个弊端就是，当需要获取某个结点p的前驱时，需要从头指针开始遍历链表，获得“前驱”的执行时间为O(n)，为了克服单向链表的这种缺点，可以利用双向链表。在双向链表中有两个...
数据结构堆排序（c语言版）
z6665454的博客
05-18 1077
在构建好堆之后,堆排序会进行反复的交换和调整操作,将堆顶元素(最大值或最小值)与堆的最后一个元素交换,然后缩小堆的规模。堆排序的优势是能够在一个数组上就地完成排序,不需要额外的空间。堆排序是一种原地排序算法,不需要额外的内存空间来辅助排序,而是直接在原数组上进行操作。大顶堆的根节点是数组中的最大值,小顶堆的根节点是数组中的最小值。堆排序的主要功能是对一个给定的数组进行升序或降序排序。大顶堆的特点是根节点的值大于或等于其左右子节点的值。堆排序的时间复杂度为O(nlogn),这使它成为高效的通用排序算法之一。
java第十三课 —— 二维数组 排序
Liuxu 的博客
05-18 1278
数组 排序 查找
Cow Exhibition G的来龙去脉
m0_61150571的博客
05-15 457
从暴力方法，到初步方法，再优化最后得到正解，完整展现思考过程。
质数和约数
最新发布
2302_77099705的博客
05-21 699
最大公约数（Greatest Common Divisor）指两个或多个整数共有约数中最大的一个。也称最大公因数、最大公因子，a， b的最大公约数记为（a，b），同样的，a，b，c的最大 公约数记为（a，b，c），多个 整数的最大公约数也有同样的记号。求最大公约数有多种 方法，常见的有 质因数分解法、 短除法、 辗转相除法、 更相减损法。
单向链表 median
11-03
单向链表的median指的是链表中位于中间位置的节点值。如果链表节点数为偶数个，那么中位数是指中间两个节点的平均值；如果链表节点数为奇数个，那么中位数是指正中间的节点的值。 要找出单向链表的中位数，可以采用...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值