数据结构之线性表(单链表）

最新推荐文章于 2022-07-13 14:25:56 发布
最新推荐文章于 2022-07-13 14:25:56 发布
阅读量647 收藏 1
点赞数 1
分类专栏： 数据结构
注意：这篇博客是我转别人的，当中有点小缺陷；在"while（p&&j<i）"元素定位中，希望大家参考。
1. 线性链表
  
    线性表的链式存储结构的特点是用一组任意的存储单元存储线性表的数据元素（这组存储单 元可以是连续 的，也可以是不连续的）。这些数据元素可以存在内存未被占用的任意位置。
   它包括两个域：其中存储数据元素信息的域称为数据域；存储直接后继存储位置的域称为指 针域。指针域 中存储的信息称为指针或链。
   由于此链表的每个结点中只包含一个指针域，故又称为线性链表或单链表。
   对于线性表来说，总得有个头有个尾，链表也不例外。我们把链表中第一个结点的存储位置 叫做头指 针，那么整个链表的存取就必须是从头指针开始进行的。之后的每个结点，其实就是上 一个后 指针指向的 位置。最后一个结点，意味着后继不再存在，所以，规定线性链表的最后一个 结点指针为“空”（通常为 NULL)。 

   线性表的单链表存储结构，如下所示。
  1. typedef struct Node
  2. {
  3.      ElemType data;
  4.      struct Node *next;
  5. }Node, LinkList;
2. 线性表的操作

   获取链表第i个数据的算法思路：

  1）声明一个结点p指向链表第一个结点，初始化j从1开始；

  2）当j<i< span="" style="word-wrap: break-word;">时，就遍历链表，p的指针向后移动，不断指向下一个结点，j累加1；

  3）若到链表末尾p为空，则说明第i个元素不存在；

  4）否则查找成功，返回结点p的数据。


  单链表第i个数据插入结点的算法思路：

  

  1）声明一个结点p指向链表的第一个结点，初始化j从1开始；

  2）当j<i< span="" style="word-wrap: break-word;">时，就遍历链表，让p的指针向后移动，不断指向下一个结点，j累加1；

  3）若到链表末尾p为空，则说明第i个元素不存在；

  4）否则查找成功，在系统中生成一个空结点s；

  5）将数据元素e赋值给s->data；

  6）单链表的插入标准语句s->next = p->next；p->next = s；

  7）返回成功。


  单链表第i个数据删除结点的算法思路：

  

  1）声明一个结点p指向单链表的第一个结点，初始化j从1开始；

  2）当j<i< span="" style="word-wrap: break-word;">时，就遍历链表，让p指针向后移动，不断指向下一个结点，j累加1；

  3）若到链表末尾p为空，则说明第i个元素不存在；

  4）否则查找成功，将欲删除的结点p->next赋值给q；

  5）单链表的删除标准语句p->next = q->next；

  6）将q结点中的数据赋值给e，作为返回；

  7）释放q结点。


  单链表的整表创建的算法思路：

  

  1）声明一个结点p和计数器变量i；

  2）初始化一空链表L；

  3）让L的头结点的指针指向NULL，即建立一个带头结点的单链表；

  4）循环

* 生成一新结点赋值给p；

* 随机生成一数字赋值给p的数据域p->data；

* 将p插入到头结点域前一新结点之间。


  单链表的整表删除的算法思路如下：

  

  1）声明一结点p和q；

  2）将第一个结点赋值给p；

  3）循环：

* 将下一个结点赋值给q；

* 释放p；

* 将q赋值给p；


3. 线性表操作的C实现

  1. #include <stdio.h>
  2. #include <stdlib.h>

  4. #define OK 0
  5. #define ERROR 1

  7. //typedef ElemType int;
  8. #define ElemType int
  9. typedef struct Node
  10. {
  11.     ElemType data;
  12.     struct Node *next;
  13. }Node, *LinkList;

  15. /* 函数功能：获取链表第i个数据
  16.  * 操作结果：用e返回L中第i个数据元素的值
  17.  * 返回值：
  18.  *         ERROR：i值不合法
  19.  *         OK     ：操作成功
  20.  *
  21.  * 最坏时间复杂度为O(n)
  22. */
  23. int GetElem(LinkList L, int i, ElemType *e)
  24. {
  25.     if( i <= 0)
  26.     {
  27.         fprintf(stderr, "i should more 1 and less LinkLength(L).\n");
  28.         return ERROR;
  29.     }
  30.     LinkList p = L->next;            //声明一结点p
  31.     int j = 1;                        //j为计数器

  33.     while(j < i && p != NULL)        //p不为空且计数器j还没有等于i时，循环继续
  34.     {
  35.         p = p->next;
  36.         j++;
  37.     }

  39.     if(!p || j > i)                    //第i个元素不存在
  40.     {
  41.         return ERROR;
  42.     }

  44.     *e = p->data;

  46.     return OK;
  47. }


  50. /* 函数名称: ListInsert
  51.  * 函数功能: 在链表的第i个位置之前插入数据元素e
  52.  * 返回值:
  53.  *        ERROR: i不合法
  54.  *        OK : 插入成功
  55.  * 
  56.  * 注意：参数L为指针的指针
  57. */

  59. int LinkInsert(LinkList *L, int i, ElemType e)
  60. {
  61.     if( i <= 0)
  62.     {
  63.         fprintf(stderr, "i<=0不合法.\n");
  64.         return ERROR;
  65.     }

  67.     LinkList p;
  68.     p = *L;
  69.     int j = 1;

  71.     while(j < i && p != NULL)            //寻找第i个结点
  72.     {
  73.         p = p->next;
  74.         ++j;
  75.     }

  77.     if(!p || j > i)                        //第i个结点不存在
  78.     {
  79.         return ERROR;
  80.     }

  82.     LinkList temp = (LinkList)malloc(sizeof(struct Node));
  83.     if(!temp)
  84.     {
  85.         fprintf(stderr, "malloc() error.\n");
  86.         return ERROR;
  87.     }

  89.     temp->data = e;

  91.     temp->next = p->next;
  92.     p->next = temp;

  94.     return OK;
  95. }

  97. /* 函数名称: ListDelete
  98.  * 函数功能: 删除L中的第i个元素，并用e返回其值
  99.  * 返回值:
  100.  *        ERROR: i不合法
  101.  *        OK : 删除成功
  102.  *
  103.  * 最坏时间复杂度为O(n)
  104. */
  105. int ListDelete(LinkList *L, int i, ElemType *e)
  106. {
  107.     if(i <= 0)
  108.     {
  109.         fprintf(stderr, "i <= 0不合法.\n");
  110.         return ERROR;
  111.     }

  113.     LinkList p,q;
  114.     p = *L;
  115.     int j = 1; 

  117.     while(j < i && p->next != NULL)        //遍历寻找第i个结点
  118.     {
  119.         p = p->next;
  120.         ++j;
  121.     }

  123.     if(p->next == NULL || j > i)
  124.     {
  125.         return ERROR;
  126.     }

  128.     q = p->next;
  129.     p->next = q->next;
  130.     *e = q->data;

  132.     free(q);
  133.     
  134.     return OK;
  135. }

  137. /* 函数名称: CreateList
  138.  * 函数功能: 随机产生n个元素的值，建立带头结点的单链表L(头插法)
  139.  * 返回值:
  140.  *        ERROR: malloc() error
  141.  *        OK : 创建成功
  142.  *
  143.  */
  144. int CreateList(LinkList *L, int n)
  145. {
  146.     LinkList p;
  147.     int i = 1;
  148.     srand(time(0));                                    //初始化随机数种子

  150.     *L = (LinkList)malloc(sizeof(struct Node));        //先建立一个带头结点的单链表
  151.     if(*L == NULL)
  152.     {
  153.         fprintf(stderr, "malloc() error.\n");
  154.         return ERROR;
  155.     }
  156.     (*L)->next = NULL;

  158.     while(i <= n)
  159.     {
  160.         p = (LinkList)malloc(sizeof(struct Node));
  161.         if( p == NULL)
  162.         {
  163.             fprintf(stderr, "malloc() error.\n");
  164.             return ERROR;
  165.         }
  166.         p->data = rand() % 100 + 1;
  167.         p->next = (*L)->next;
  168.         (*L)->next = p;                                    //插入到表头
  169.         
  170.         i++;
  171.     }
  172.     /*
  173.     //尾插法
  174.     LinkList r；
  175.     r = *L;                                                //r为指向尾部的结点
  176.     for(i = 0; i < n; i++)
  177.     {
  178.         p = (LinkList)malloc(sizeof(struct Node));        //生成新结点
  179.         p->data = rand() % 100 + 1;
  180.         r->next = p;                                    //将表尾终端结点的指针指向新结点
  181.         r = p;                                            //将当前的新结点定义为表尾部结点
  182.     }
  183.     r->next = NULL;                                        //表示当前链表结束
  184.     */
  185.     return OK;
  186. }

  188. /* 函数名称: ClearList
  189.  * 函数功能: 单链表删除
  190. */
  191. int ClearList(LinkList *L)
  192. {
  193.     if(*L == NULL)
  194.     {
  195.         return ERROR;
  196.     }

  198.     LinkList q, p;
  199.     p = (*L)->next;        //p指向第一个结点

  201.     while(p)            //没有到表尾部
  202.     {
  203.         q = p->next;    //注意哦
  204.         free(p);
  205.         p = q;
  206.     }

  208.     (*L)->next = NULL;    //头结点指针域为空

  210.     return OK;
  211. }

  213. int printList(LinkList L)
  214. {
  215.     LinkList p;
  216.     p = L->next;
  217.     if(p == NULL)
  218.     {
  219.         printf("链表为空.\n");
  220.         return ERROR;
  221.     }
  222.     while(p)
  223.     {
  224.         printf("%d ", p->data);
  225.         p = p->next;
  226.     }
  227.     printf("\n");

  229.     return OK;
  230. }

  232. int main(int argc, char **argv)
  233. {
  234.     LinkList L;
  235.     
  236.     printf("创建的新链表为:\n");
  237.     CreateList(&L, 5);
  238.     printList(L);
  239.     
  240.     printf("在第3个位置之前插入元素10后结果为:\n");
  241.     LinkInsert(&L, 3, 10);
  242.     printList(L);

  244.     int e;
  245.     GetElem(L, 3, &e);     
  246.     printf("链表第3个位置的元素为: %d\n", e);
  247.     
  248.     printf("删除第3个位置的元素后结果为:\n");
  249.     ListDelete(&L, 3, &e);
  250.     printList(L);
  251.     
  252.     printf("清空链表:\n");
  253.     ClearList(&L);
  254.     printList(L);
  255.     
  256.     return 0;
  257. }
    运行环境：RedHat
   编译工具：Gcc
   
   运行结果如下所示：




    参考：严蔚敏老师之《数据结构》

mazhuang521
关注
专栏目录
数据结构---线性表之单链表（C语言）
03-28
单链表是数据结构中的一种基础类型，尤其在C语言编程中经常被使用。它是一种线性的、非连续的数据组织形式，每个元素称为节点，每个节点包含数据和一个指向下一个节点的指针。本篇文章将深入探讨单链表的创建、插入...
03线性表 链表表示
Tian Meng的博客
03-02 506
线性表 链表表示
数据结构--线性表--链表（转自B站视频）
YQyq1021的博客
07-13 706
线性表：用一组物理位置任意的存储单元来存放线性表的数据元素。存储单元可以是连续，也可以是不连续的。 它不仅要存储当前元素的地址，还要存储下一个元素的地址。这样即便它的存储地址不是连续的0001，0002，0003，0004，（真实存储地址为：0002，0003，0001，0004），也能找到。 把存储下一个元素的地址称为指针域。它本身称为数据域（不是指的是存储地址，而是学生，姓名这种名称，由这两个构成一个结点，由若干个结点构成就是链表。记录第一个元素的地址称为头指针，其中单链表由头指针唯一确定，因此单链表可
数据结构和算法（三）线性表——链表
C-A-L-D
08-26 1420
链表由若干个“节点”组成，每个节点含有数据域和指针域 有一个指针域，就是单向链表；两个指针域，可以组成双向链表 链表有链头和链尾，链头数据域必须为null，链尾指针域必须为null 单链表： 链表插入和删除只需要修改指节点对应的针域指针指向即可！ 单链表API设计： package cn.itcast.algorithm.linear; import java.util.Iterator; public class LinkList<T> imple...
数据结构之线性表（单链表一）
小言同学的博客
11-28 717
一、概念 1、链式存储结构 结点在存储器中的位置是任意的，即逻辑上相邻的数据元素在物理上不一定相邻； 2、线性表的链式表示又称为非顺序映像或链式映像。 3、链表中元素的逻辑次序和物理次序不一定相同。 4、结点：由数据域和指针域两部分组成 数据域：存储元素数值数据； 指针域：存储直接后继结点的存储位置。 5、单链表：只有一个指针域的链表； 双链表：结点有两个指针域的链表； 循环链表：首尾相接的链表。 6、头指针：...
线性结构 — 单链表
qq_40120946的博客
08-19 302
链表定义 使用结点来存储数据元素。 链表结点 数据域：用于存储元素的值 指针域：存储元素的直接前驱或直接后驱的地址 结点之间通过指针域构成一个链表。若结点中只有一个指针域，则称为单链表。 链表优缺点： 链表中各数据元素的结点地址则不要求是连续的，因此必须同时存储元素之间的逻辑关系 链表的插入、删除操作都比较方便，只需修改指针域的指向即可。 /* 单链表 */ #include<iostream> #include<cstdlib> using namespace .
Java数据结构之线性表
08-31
Java中的线性表是一种基本的数据结构，它由一系列具有线性关系的元素构成，这些元素在逻辑上形成一个序列。线性表支持多种操作，包括获取元素、设置元素值、遍历、插入、删除、查找、替换和排序。线性表的存储方式有...
数据结构之线性表的实现.rar
07-27
在这个压缩包“数据结构之线性表的实现.rar”中，我们可以找到关于线性表实现的详细内容，特别是针对严蔚敏版数据结构的实现。 线性表的常见实现方式有两种：顺序表和链表。在顺序表中，元素在内存中是连续存储的，...
数据结构线性表的C语言代码
06-27
适合学习数据结构的同学
数据结构之线性表（顺序表、单链表、双链表）
最新发布
08-26
数据结构之线性表（顺序表、单链表、双链表）
数据结构——线性表相关重要知识点说明
＃两个西柚
07-25 1388
数据结构——线性表相关重要知识点说明 1.引用类型作形参的三点说明： (1)传递引用给函数与传递指针的效果是一样的，形参变化实参也发生变化。 (2)引用类型作形参，在内存中并没有产生实参的副本，它直接对实参操作;而- -般变量作参数,形参与实参就占用不同的存储单元,所以形参变量的值是实参变量的副本。因此，当参数传递的数据量较大时，用引用比用一般变量传递参数的时间和空间效率都好。 (3)指针参数虽然也能达到与使用引用的效果，但在被调函数中需要重复使用“*指针”变量名”的形式进行运算，这很容易产生错误且程序的阅
链表基础知识
青山的青衫的博客
02-03 1953
链表基础知识链表的类型链表的类型单链表双链表循环链表存储方式代码——链表的定义链表的操作删除结点添加结点性能分析 链表的类型 什么是链表，链表是一种通过指针串联在一起的线性结构，每一个节点是又两部分组成，一个是数据域一个是指针域（存放指向下一个节点的指针），最后一个节点的指针域指向null（空指针的意思）。 链接的入口点称为列表的头结点也就是head。 链表的类型 单链表 刚刚即是 双链表 单链表中的节点只能指向节点的下一个节点。 双链表：每一个节点有两个指针域，一个指向下一个节点，一个指向上一个节
安卓选择年月控件_2019年3月新增选择题（一）
weixin_39859394的博客
12-04 915
1、小吕在利用 PowerPoint 2010 制作旅游风景简介演示文稿时插入了大量的图片，为了减小文档体积以便通过邮件方式发送给客户浏览，需要压缩文稿中图片的大小，最优的操作方法是( )：A) 在PowerPoint中通过调整缩放比例、剪裁图片等操作来减小每张图片的大小B) 直接利用压缩软件来压缩演示文稿的大小C) 先在图形图像处理软件中调整每个图片的大小，再重新替换到演示文稿中D...
数据结构与算法——线性表（链表篇）
小田是个程序员的博客欢迎你的到来呀~
06-20 2万+
本篇文章，主要详细解读和总结线性表的链式存储结构——链表，包括单链表、双链表、静态链表以及循环链表，讲解较为全面，图文并茂，总结各链表的特性以及基本操作，干货满满，各位小伙伴们请细细品读，你会收获你想要的知识的！.........
数据结构与算法学习笔记-线性表
qq_53548177的博客
12-10 651
声明：本博客仅为本人学习途中做的笔记 采自青岛大学王卓老师的视频教学 主要内容为算法思路，具体代码实现还需修改后才能运行，望各位看官多多包涵，您的点赞与评论是对我最大的肯定！ # 1.线性表的定义和特点 线性表是具有相凤特性的数据元素的一个有限序列 (a1,a2,...ai−1,ai,ai+1,...,an) (a_1, a_2, ... a_i-_1, a_i,a_i+_1, ..., a_n) (a1​,a2​,...ai​−1​,ai​,ai​+1​,...,an​)\qquad\qquad\q.
数据结构和算法（C）------4.线性表（2）单链表
weixin_41769717的博客
11-21 1705
1.链式存储结构 1.1 定义 结点在存储器中的位置是任意的，即逻辑上相邻的数据元素在物理上不一定相邻。线性表的链式表示又称为非顺序映像或链式映像。 1.2 实现方式 各节点有两个域组成：数据域和指针域 数据域：存储数据 指针域：存储后续节点的地址 1.3 与链式存储有关的术语 结点 链表 单链表、双链表、循环链表 头指针、头结点和首元结点 1、结点：数据元素的存储映像。由数据域和指针域两部分组成 2、链表： n 个结点由指针链组成一个链表。它...
公共基础数据结构与算法（一）
m0_46394800的博客
03-20 1406
1、对长度为n的线性表排序，在最坏的情况下： 比较次数为nlog2n的排序方法：堆排序（比较次数最少）； 比较次数是n(n-1)/2的排序方法是：快速排序、直接插入排序、冒泡排序。 希尔排序：nr（1<r<2）。 2、栈：按照“先进后出”或“后进先出”的原则组织数据（出栈与进栈顺序相反），队列是先进先出，只能在栈顶这一端插入和删除数据（栈顶元素最先被删除；当栈中只剩下栈底一个元素时，栈...
常用数据结构--线性结构
热门推荐
袁伏彪 —— 共享，共赢
04-27 2万+
数据结构是计算机存储、组织数据的方式。常见的数据结构分类方式如下图： 常用的线性结构有：线性表，栈，队列，循环队列，数组。线性表中包括顺序表、链表等，其中，栈和队列只是属于逻辑上的概念，实际中不存在，仅仅是一种思想，一种理念；线性表则是在内存中数据的一种组织、存储的方式。   顺序表 顺序表将元素一个接一个的存入一组连续的存储单元中，在内存物理上是连续的。如下图：
2015未来教育计算机,2015年计算机二级MS Office习题及答案解析(1)
weixin_36173940的博客
06-15 570
2015年计算机二级MS Office习题及答案解析(1)浏览次数： 时间：2015/11/171[单选题]下列叙述中正确的是( ).A.结点中具有两个指针域的链表一定是二叉链表B.结点中具有两个指针域的链表可以是线性结构，也可以是非线性结构C.二叉树只能采用链式存储结构D.循环链表是非线性结构参考答案：B参考解析：具有两个指针域的链表可能是双向链表，A选项错误。双向链表是线性结构，二叉树...
数据结构：线性表与单链表
"这篇资料主要介绍了带表头结点的单链表，它是数据结构中的一个重要概念，特别是在处理线性表时。线性表是一种由n（n≥0）个数据元素组成的有限序列，其中每个元素都有一个直接前驱和一个直接后继，除了首尾元素。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值