C 算法精介----链表（1）

最新推荐文章于 2024-05-23 17:21:25 发布
最新推荐文章于 2024-05-23 17:21:25 发布
阅读量627 收藏
点赞数

C算法 ---链表

转载于http://blog.youkuaiyun.com/jsh13417/article/details/8297093?reload

链表是一种最为基础的数据结构，链表是由一组元素以一种特定的顺序组合或链接在一起的。在维护数据的集合时很有用途。在平时的数据处理过程中经常会会用链接进行数据的临时存储。但是如何才能使链表处理数据更加优化，下面简单介绍单链表处理情况！

1 、单链表介绍

单链表是各个元素之间通过一个指针彼此连接起来而组成的。元素可以分为2个部分：数据成员和一个称为nest的指针。通过这种2成员结构，将每个元素的next指针指向其元素后面的指针。为了更能描述这种结构可以看下图：

要访问链表中的元素，从链表的头部开始，通过next指针从一个元素到另一个元素。然而每个元素的都需要动态的申请和释放空间。元素和元素之间的连接关系可以确保每个元素都能够访问到。因为在对数据处理时，一定要特别的小心。如果中间丢失掉一个元素，后面的就无法访问到。

2 单链表的实现和分析

示例1 链表抽象的数据类型的头文件

[csharp] view plain copy print ?
  1. #ifndef LIST_H
  2. #define LIST_H
  4. #include <stdlib.h>
  5. /*define a structure for linked List elements */
  6. typedef struct ListElmt_{
  7. void *data;
  8. struct ListElmt_ *next;
  9. }ListElmt;
  11. /*define a structure for linked lists */
  12. typedef struct List_ {
  13. int size;
  14. int (*match)(constvoid * key1,constvoid * key2);
  15. void (*destroy)(void *data);
  16. ListElmt *head;
  17. ListElmt *tail;
  18. }List;
  20. /*Public Intefaces */
  21. void list_init(List *list,void (*destroy)(void *data));
  22. void list_destory(List *list);
  23. int list_ins_next(List *list, ListElmt *element,constvoid *data);
  24. int list_rem_next(List *list, ListElmt *element,void *data);
  26. #define list_size(list) ((list) -> size)
  27. #define list_head(list) ((list) -> head)
  28. #define list_tail(list) ((list) -> tail)
  29. #define list_is_head(list, element) ((element) == (list) -> head ? 1:0)
  30. #define list_is_tail(list, element) ((element) == (list) -> tail ? 1:0)
  31. #define list_data(element) ((element) -> data)
  32. #define list_next(element) ((element) -> next)
  35. #endif 
 
示例2 链表抽象数据类型的实现
[csharp] view plain copy print ?
  1. #include <studio.h>
  2. #include <string.h>
  4. #include "../include/List.h"
  6. /*list_init */
  7. void list_init(List * list,void(* destroy)(void * data)) {
  8. /* initialize the list */
  9. list -> size = 0;
  10. list -> destroy = destroy;
  11. list -> head = NULL;
  12. list -> tail = NULL;
  14. return ;
  15. }
  17. /*list_destroy */
  18. void list_destory(List * list) {
  19. void *data;
  20. /*Remove eah element */
  21. while (list_size(list) > 0){
  22. if (list_rem_next(list, NULL, (void **) &data) == 0 && list -> destroy
  23. != NULL){
  24. /* Call a user-defined function to free dynamically allocated data*/
  25. list -> destroy(data);
  26. }
  27. }
  28. memset(list, 0, sizeof(List));
  29. return;
  30. }
  32. /*list_ins_nest */
  33. int list_ins_next (List * list, ListElmt * element,constvoid * data){
  34. ListElmt *new_element;
  36. /* Allocate storage for the element */
  37. if ((new_element = (ListElmt *)malloc(sizeof(ListElmt))) == NULL){
  38. return -1;
  39. }
  41. /*insert the element into the list */
  42. new_element ->data =(void *)data;
  43. if (element == NULL){
  45. /* handle insertion at the head of the list */
  46. if (list_size(list) == 0){
  47. list -> tail = new_element;
  48. }
  50. new_element ->next = list ->head;
  51. list -> head = new_element;
  52. } else {
  53. /*Handle insertion somewhere other than at the head */
  54. if (element ->next == NULL ){
  55. list ->tail = new_element;
  56. }
  58. new_element ->next = element ->next;
  59. element->next = new_element;
  61. }
  62. list->size ++;
  63. return 0;
  65. }
  67. /* list_rem_next */
  68. int list_rem_next(List * list, ListElmt * element,void * data) {
  69. ListElmt *old_element;
  70. /* Do not allow removal from an emptry list */
  71. if (list_size(list) == 0){
  72. return -1;
  73. }
  75. /* romove the element from the list */
  76. if (element == NULL){
  78. /* handle removel from the head of the list */
  79. *data = list->head->data;
  80. old_element = list ->head;
  81. list->head = list -> head->next;
  83. if (list_size(list) == 1){
  84. list->tail = NULL;
  85. }
  86. } else {
  87. /* handle removal from somewhere other than the head */
  88. if ( element->next == NULL){
  89. return -1;
  90. }
  91. *data = element->next->data;
  92. old_element = element->next;
  93. element->next = element->next->next;
  95. if (element ->next == NULL){
  96. list->tail = NULL;
  97. }
  99. }
  100. /* free the storage allocated by the abstract datatype*/
  101. free(old_element);
  103. list->size --;
  104. return 0;
  105. }

  106. 3 下面对几个重要的函数接口实现进行介绍

list_init

list_init用来初始化一个链表仪表能够执行其他的操作，主要成员的描述：

size：链表中元素的个数；初始化为0；

destroy：定义的一个析构函数（http://baike.baidu.com/view/1277985.htm）；初始换有函数参数传入；

head和tail：2个指针主要表头和表尾。初始化为NULL；

list_destroy

list_destroy 用来销毁链表，也就是取出链表中的所有函数；

函数主要是循环判断size，直到size为0时退出。函数的实现是调用函数list_rem_next，第二个参数为NULL时，表示，从第一个元素开始删除。如果析构函数不为NULL，则应该调用析构函数。

list_ins_next

list_ins_next 将一个元素插入有element指定的元素之后。新元素的数据只想由用户传入的数据。想链表中插入数据要有2中情况要考虑：插入头或其他位置，具体参照函数的实现。当传入参数element为NULL，表示从插入到表头；

list_rem_next

list_rem_next 从链表中移除指定元素之后的那个节点，并将其保存的数据保存的参数data中；同样也需要考虑2中情况：删除头或者其他位置的。当参数element为NULL时，表示从表头删除！

4 双向链表

双向链表,如同名字所暗示的那样，链表元素之间由2个指针链接，双向链表中的每一个元素都有3部分组成：除了数据成员和指针next外，新增加了一个指针prev，指向其前驱元素的指针。下图清晰绘出双向链表的结构：

双向链表的实现和分析

[csharp] view plain copy print ?
  1. #ifndef DLIST_H
  2. #define DLIST_H
  3. #include <stdlib.h>
  5. /*define a structure for doubly-linked list elements */
  6. typedef struct DlistElmt_ {
  7. void *data;
  8. struct DlistElmt_ *prev;
  9. struct DlistElmt_ *next;
  10. }DlistElmt;
  12. /*define a structure for doubly-linked lists */
  13. typedef struct Dlist_ {
  14. int size;
  15. int (*match)(constvoid *key1,constvoid * key2);
  16. void (*destroy)(void *data);
  17. DlistElmt *head;
  18. DlistElmt *tail;
  19. }Dlist;
  21. /*Public Intefaces */
  22. void dlist_init(Dlist *dlist,void (*destroy)(void *data));
  23. void dlist_destory(Dlist *dlist);
  24. int dlist_ins_next(Dlist *dlist, DlistElmt *element,constvoid *data);
  25. int dlist_ins_prev(Dlist *dlist, DlistElmt *element,constvoid *data);
  26. int dlist_remove(Dlist *dlist, DlistElmt *element,void *data);
  28. #define dlist_size(dlist) ((dlist) ->size)
  29. #define dlist_head(dlist) ((dlist) ->head)
  30. #define dlist_tail(dlist) ((dlist) ->tail)
  31. #define dlist_is_head(element) ((element) ->prev == NULL? 1:0)
  32. #define dlist_is_tail(element) ((element) ->next == NULL ? 1:0)
  33. #define dlist_data(element) ((element) ->data)
  34. #define dlist_next(element) ((element) ->next)
  35. #define dlist_prev(element) ((element)->prev)
  37. #endif


[csharp] view plain copy print ?
  1. /* dlist.c */
  2. #include <stdlib.h>
  3. #include <string.h>
  5. #include "../include/Dlist.h"
  7. /*dlist_init */
  8. void dlist_init(Dlist * dlist,void(* destroy)(void * data)){
  9. /* initialize the list */
  10. list -> size = 0;
  11. list -> destroy = destroy;
  12. list -> head = NULL;
  13. list -> tail = NULL;
  15. return ;
  16. }
  18. /*list_destroy */
  19. void dlist_destory(Dlist * dlist){
  20. void *data;
  21. /*Remove eah element */
  22. while (dlist_size(dlist) > 0){
  23. if (dlist_remove(dlist, dlist_tail(dlist), (void **) &data) == 0 && dlist -> destroy
  24. != NULL){
  25. /* Call a user-defined function to free dynamically allocated data*/
  26. dlist ->destroy(data);
  27. }
  28. }
  29. memset(dlist, 0, sizeof(Dlist));
  30. return;
  31. }
  33. /*dlist_destroy */
  34. void dlist_destory(Dlist * dlist) {
  35. void *data;
  37. /* remove each element */
  38. while (dlist_size(dlist) > 0){
  39. if (dlist_remove(Dlist * dlist, dlist_tail(dlist),void * data) == 0 &&
  40. dlist->destroy != NULL){
  41. /* call a user-defined function to free dynamically allocated data */
  42. dlist->destroy(data);
  44. }
  46. }
  47. memset(list,0,sizeof(Dlist));
  48. return;
  50. }
  51. /* dlist_ins_next */
  52. int dlist_ins_next(Dlist * dlist, DlistElmt * element,constvoid * data){
  53. DlistElmt *new_element;
  54. /* do not allow a NULL element unless dlist is empty*/
  55. if (element == NULL && dlist_size(dlist) == 0){
  56. return -1;
  57. }
  59. /* allocate storage for the element */
  60. if ((new_element = (DlistElmt *)malloc(sizeof(DlistElmt))) == NULL){
  61. return -1;
  62. }
  64. new_element->data = (void *) data;
  65. if (dlist_size(dlist) == 0){
  66. dlist->head = new_element;
  67. new_element->prev = NULL;
  68. new_element->next = NULL;
  69. dlist->tail = new_element;
  70. } else {
  71. new_element->next = element->next;
  72. new_element->prev = element;
  73. if (element->next == NULL){
  74. dlist->tail = new_element;
  75. } else {
  76. element->next->prev = new_element;
  77. }
  78. element->next = new_element;
  79. }
  80. dlist->size++;
  81. return 0;
  82. }
  84. int dlist_ins_prev(Dlist * dlist, DlistElmt * element,constvoid * data){
  85. DlistElmt *new_element;
  86. /* do not allow a NULL element unless dlist is empty*/
  87. if (element == NULL && dlist_size(dlist) == 0){
  88. return -1;
  89. }
  91. /* allocate storage for the element */
  92. if ((new_element = (DlistElmt *)malloc(sizeof(DlistElmt))) == NULL){
  93. return -1;
  94. }
  96. new_element->data = (void *) data;
  97. if (dlist_size(dlist) == 0){
  98. dlist->head = new_element;
  99. new_element->prev = NULL;
  100. new_element->next = NULL;
  101. dlist->tail = new_element;
  102. } else {
  103. new_element->next = element;
  104. new_element->prev = element->prev;
  105. if (element== NULL){
  106. dlist->tail = new_element;
  107. } else {
  108. element->prev->next= new_element;
  109. }
  110. element->prev = new_element;
  111. }
  112. dlist->size++;
  113. return 0;
  114. }
  115. int dlist_remove(Dlist * dlist, DlistElmt * element,void * data) {
  116. /*do not allow a NULL element or removal from an empty list */
  117. if (element == NULL || dlist_size(dlist) == 0){
  118. return -1;
  119. }
  121. /* Remove the element from the list */
  122. *data = element->data;
  124. if (element == dlist->head){
  125. /*handle removal from the head of the list */
  126. dlist->head = element->next;
  127. if (dlist->head ==NULL){
  128. dlist->tail = NULL;
  129. } else {
  130. element->next->prev = NULL;
  131. }
  132. } else {
  133. element->prev->next = element ->next;
  134. if (element->next == NULL){
  135. dlist->tail = element->prev;
  136. } else {
  137. element ->next->prev = element->prev;
  138. }
  139. }
  140. free(element);
  141. dlist->size--
  142. return 0;
  143. }


以上便是双向链表的函数实现过程，具体就不在分析了，和单向链表差不多！

wushanlong
关注
C 算法精介----链表->双向链表
TTc 's share
02-02 605
双向链表 双向链表,如同名字所暗示的那样，链表元素之间由2个指针链接，双向链表中的每一个元素都有3部分组成：除了数据成员和指针next外，新增加了一个指针prev，指向其前驱元素的指针。下图清晰绘出双向链表的结构： // // DList.c // Algorithms&Data_structures // // Created by TTc on
数据结构--队列--链式队列入队、出队等基本操作的实现（C语言）
羟基与苯的博客
04-15 1万+
文章目录🎄链式队列结构定义⭐1.创建并初始化队列⭐2.入队⭐3.出队⭐4.遍历打印链式队列中的元素⭐5.判断队空⭐6.计算队列中的数据个数⭐7.动态内存释放🎄各操作测试代码及结果 本文涉及完整代码及测试代码均已提交至Gitee，大家可以点击链接参考。 鄙人乃一介初学者，文中及代码中难免出错，恳请同志们雅正！ 我们在之前使用顺序结构的存储方式实现了队列，其中因为要解决时间复杂性还使用了循环队列来实现。既然队列是一个线性表，那么使用链式结构同样可以实现队列。接下来我们看看如何实现链式队列。 🎄链式队
求点介数C++实现 Betweenness Centrality
03-17
蛋白质相互作用网络中求解Betweenness Centrality的简单方法，用C++实现，需改进
介数计算（c语言版）
07-22
c语言写的 介数计算 基于广度优先搜索技术（适合与无权无向网络）
通用链表操作接口函数
young honker
06-20 1876
list.c/* * *通用链表操作函数定义 ** */ #include #include #include #include "list.h" /*链表初始化*/ void list_init(List *list) { list->head = NULL; list->tail = NULL; list->len = 0; } /*是否为空链表*/ boo
介数中心性算法实现
01-23
python实现的介数中心算法
Maxipy/openmv源码分析--list_t
qq_32497777的博客
04-23 896
openmv中用到很多结构体list_t，通过对于这个结构体的实现，可以使用一些面向对象的思想。 在collections.h中定义的相关结构体和功能函数声明。 ////////// // list // ////////// typedef struct list_lnk { struct list_lnk *next_ptr, *prev_ptr; char data[]; } __attribute__((aligned(8)))list_lnk_t; typedef str
C/C++——排列算法
最新发布
qq_63302957的博客
05-23 680
这让我想起了单调队列优化，可以将所有小球当作一个有序链表，如果已经放了一个小球，直接用链表的删除操作删除对应节点，而删除操作是不增加时间复杂度的。想法可行，直接开始优化。（排列数）输入两个正整数 𝑛,𝑚(1≤𝑛≤20,1≤𝑚≤𝑛)n,m(1≤n≤20,1≤m≤n)，在 1∼𝑛1∼n 中任取 𝑚m 个数，按字典序从小到大输出所有这样的排列。上面的算法时间复杂度会变成O(nm)是因为在我已经选择了一个小球也就是选择了一个编号之后，我并没有将其剔出待选集，也就少了一个筛选操作，这其实并没有对整个过程的正确模拟。
2023秋招大厂经典面试题及答案整理归纳（201-220）校招必看
m0_58687318的博客
08-19 1340
情况一：两条单链表均无环最简单的一种情况，由于两条链表如果交叉，他们的尾节点必然相等(Y字归并)， 所以只需要判断他们的尾节点是否相等即可。情况二：两条单链表均有环这种情况只需要拆开一条环路(注意需要保存被设置成null的节点)，然后判断 另一个单链表是否仍然存在环路，如果有在，说明无交叉，反之，则有交叉的情况。情况三:两条单链表，一条有环路，一条无环路这种情况显然他们是不可能有交叉的附：如何判断一条单链表是否存在环路，以及找出环路的入口。
PTA 6-4 查找元素(*)
wcd278212784的博客
03-31 2513
6-4 查找元素(*)添加链接描述 已知顺序表的结构定义如下： typedef struct { int size, length; int *element; } ALIST; 说明：element 为存储数据元素的动态数组的起始地址，size 为动态数组的尺寸，length 为顺序表的长度。 请编写函数，在顺序表中查找数据元素。 函数原型 int AListFind(const ALIST *list, int element); 说明：参数 list 为指示线性表(顺序表)的指针，element 为待
数据结构中链表结构原理及其算法实现
一笑的博客
04-05 2552
C语言数据结构中常见的一些基础的链表操作，原来这么简单！
关于链表，看这一篇就够了！（新手入门）
m0_52532896的博客
04-20 7万+
将某个变量赋值给指针，实际上就是将这个变量的地址赋值给指针，或者反过来说，指针中存储了这个变量的内存地址，指向了这个变量，通过指针就能找到这个变量。
链表基础知识详解（非常详细简单易懂）
热门推荐
qq_61672347的博客
07-10 21万+
数据结构链表详解，创建，遍历，释放，节点的查找，节点的删除，插入节点，链表排序等操作，非常详细
算法精解（一）：C语言描述（链表）
qq_32579021的博客
11-19 693
1.链表认知  一场病，断了好久。这几天算是基本没什么问题了。是时候继续了。 链表我想可以认为是，点到线的过程。 一个个点就是一个个链表的节点，以特定的顺序组合或链接后，行成了一条线，即链表。所以添加，删除一个点是相对较容易的（因为可以动态的追加，删除节点），但是查找某个点相对较麻烦（数组中只需要a[i]即可取得数据，链表则需要遍历）。所以，对于未知大小长度的数据来说，具有相当的优势。但已知...
数据结构学习之单向链表结构
落魄影子
12-06 1万+
注：本文的主要目的是为了记录自己的学习过程，也方便与大家做交流。 转载请注明来自： http://blog.youkuaiyun.com/ab198604/ 最近突然间觉得应该补补IT技术的基础的知识，因为对这些基础知识的梳理不仅可以对自己所掌握的知识进一步巩固，无论是提高自身的技术水平方面还是从后期就业方面，都是大有裨益的，所以还是要打好基础，一步一个脚印才行，总之，知识需要有时间的积累。 从前自己并
算法精解_C语言 链表_单链表(接口定义+类型实现)
idreamo的博客
10-30 901
链表可以说是一种最为基础的数据结构。链表由一组元素以一种特定的顺序组合或链接而成，在维护数据的集合时很有用。这一点同我们常用的数组很相似。然而，链表在很多情况下比数组更有优势。特别是在执行插入和删除操作时链表拥有更高的效率。链表需要动态的开辟存储空间，也就是存储空间是在程序运行时分配的。由于在很多应用中数据的大小在编译时并不能确定，因此这种动态分配空间的特性也是链表的一个优点。
数据结构和算法3:重要的链表
weixin_42278523的博客
07-21 148
1. 链表是什么？ 顺序表的缺点 添加和删除操作需要移动元素。 当数据量特别大的情况，可能没有连续的内存可使用。 链表，别名链式存储结构或单链表，用于存储逻辑关系为 “一对一” 的数据。与顺序表不同，链表不限制数据的物理存储状态。顺序表通过连续的地址建立元素之间前后连接关系，链表通过指针方式建立元素之间前后连接关系。 2. 链表怎么用？ 链表用法与顺序表相似，只是适用场景有所不同。 3. 链表如何实现 3.1 定义结构 使用链表存储的数据元素，其物理存储位置是随机的。数据元素随机存储，并通过指针表
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值