嵌入式初学-C语言-数据结构--二

最新推荐文章于 2024-10-03 21:40:01 发布
最新推荐文章于 2024-10-03 21:40:01 发布
阅读量1.1k 收藏 28
点赞数 17
文章标签： c语言 数据结构 开发语言 嵌入式硬件 服务器 链表 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/MaBaB/article/details/141650780
版权

#接嵌入式初学-C语言-数据结构--一#

5. 单链表

5.1 基本概念

顺序表：顺序存储的线性表。

链式表：链式存储的线性表，简称链表。

既然顺序存储中的数据因为挤在一起而导致需要成片移动，那很容易想到的解决方案是将数据离散地 存储在不同内存块中，然后在用来指针将它们串起来。这种朴素的思路所形成的链式线性表，就是所 谓的链表。

顺序表和链表在内存在的基本样态如下图所示：

 5.2 链表的分类

根据链表中各个节点之间使用指针的个数，以及首尾节点是否相连，可以将链表细分为如下种类：

1. 单向链表

2. 单向循环链表

3. 双向循环链表

这些不同链表的操作都是差不多的，只是指针数目的异同。以最简单的单向链表为例，其基本示意图

如下所示：

上图中，所有的节点均保存一个指针，指向其逻辑上相邻的下一个节点（末尾节点指向空）。另外注 意到，整条链表用一个所谓的头指针 head 来指向，由 head 开始可以找到链表中的任意一个节点。 head 通常被称为头指针。

链表的基本操作，一般包括：

1. 节点设计

2. 初始化空链表

3. 增删节点

4. 链表遍历

5. 销毁链表 

5.3 单链表节点设计 

单向链表的节点非常简单，节点中除了要保存用户数据之外（这里以整型数据为例），只需要增加一 个指向本类节点的指针即可，如下所示：

typedef int DATA;
typedef struct Node
{
DATA data; // 存储数据---数据域
struct Node *next; // 存储下一个节点的地址---指针域
} NODE;

5.4 单链表初始化

首先，空链表有两种常见的形式。一种是带所谓的头结点的，一种是不带头结点的。所谓的头结点是 不存放有效数据的节点，仅仅用来方便操作，如下：

而不带头结点的空链表如下所示： 

注意：

1.头指针 head 是必须的，是链表的入口

2.头节点是可选的，为了方便某些操作 

由于头结点是不存放有效数据的，因此如果空链表中带有头结点，那么头指针 head 将永远不变，这会 给以后的链表操作带来些许便捷。

下面以带头结点的链表为例，展示单向链表的初始化的示例代码： 

/*
@function: int slist_create(NODE** head,DATA data);
@berif: 创建单项链表
@argument: head: 指向头指针变量的地址，用来接收首节点地址
data: 存储在节点中的数据
@return : 成功返回 0
失败返回 -1
*/
int slist_create(NODE** head,DATA data)
{
NODE* p = (NODE*)malloc(sizeof(NODE));
if(!p)
{
return -1;
}
p -> data = data;
p -> next = NULL;
*head = p;
return 0;
}

5.5 单链表增删节点

相对于顺序表需要整片移动数据，链表增删节点只需要修改几个相关指针的指向，动作非常快速。 与顺序表类似，可以对一条链表中的任意节点进行增删操作，示例代码是：

/*
@function: int slist_addHead(NODE** head,DATA data);
@berif: 向链表头部插入一个节点数据
@argument: head: 指向头指针变量的地址，用来接收首节点地址
data: 存储在新节点中的数据
@return : 成功返回 0
失败返回 -1
*/
int slist_addHead(NODE** head,DATA data)
{
NODE* p = (NODE*)malloc(sizeof(NODE));
if(!p)
{
return -1;
}
p -> data = data;
p -> next = *head;
*head = p;
return 0;
}
/*
@function: int slist_addTail(NODE** head,DATA data);
@berif: 向链表尾部插入一个节点数据
@argument: head: 指向头指针变量的地址，用来接收首节点地址
data: 存储在新节点中的数据
@return : 成功返回 0
失败返回 -1
*/
int slist_addTail(NODE** head,DATA data)
{
NODE * pNew = (NODE*)malloc(sizeof(NODE));
if(!pNew)
{
return -1;
}
pNew -> data = data;
pNew -> next = NULL;
NODE* p = *head, *q = NULL;
if(!p)
{
*head = pNew;
return 0;
}
while(p)
{
q = p;
p = p -> next;
}
q -> next = pNew;
return 0;
}
/*
@function: int slist_insert(NODE** head,DATA pos ,DATA data);
@berif: 向链表节点值为pos的位置插入一个节点数据data
@argument: head: 指向头指针变量的地址
pos: 插入节点位置的节点数据
data: 存储在新节点中的数据
@return : 成功返回 0
失败返回 -1
*/
int slist_insert(NODE** head,DATA pos,DATA data)
{
NODE *pNew = (NODE*)malloc(sizeof(NODE));
if(!pNew)
return -1;
pNew -> data = data;
pNew -> next = NULL;
NODE *p = *head, *q = NULL;
if(!p)
{
*head = pNew;
return 0;
}
if(memcmp(&(p -> data),&pos,sizeof(DATA)) == 0)
{
pNew -> next = *head;
*head = pNew;
return 0;
}
while(p)
{
if(memcmp(&(p -> data),&pos,sizeof(DATA)) == 0)
{
pNew -> next = p;
q -> next = pNew;
return 0;
}
q = p;
p = p -> next;
}
q -> next = pNew;
return 0;
}
/*
@function: int slist_update(const NODE* head,DATA old,DATA newdata);
@berif: 更新链表数据old 为 newdata
@argument: head: 指向头指针变量
old: 待更新的节点数据
newdata: 更新后的节点数据
@return : 成功返回 0
失败返回 -1
*/
int slist_update(const NODE* head,DATA old,DATA newdata)
{
NODE* p = NULL;
if(!(p = slist_find(head,old)))
return -1;
p -> data = newdata;
return 0;
}
/*
@function: int slist_delete(NODE** head,DATA data);
@berif: 删除链表中节点值为data的节点
@argument: head: 指向头指针变量的地址
data: 删除节点中的数据
@return : 成功返回 0
失败返回 -1
*/
int slist_delete(NODE** head,DATA data)
{
NODE *p = *head, *q = NULL;
if(!p)
return -1;
if(memcmp(&(p -> data),&data,sizeof(DATA)) == 0)
{
*head = p -> next;
free(p);
return 0;
}
while(p)
{
if(memcmp(&(p -> data),&data,sizeof(DATA)) == 0)
{
q -> next = p -> next;
free(p);
return 0;
}
q = p;
p = p -> next;
}
return -1;
}

注意:

        删除链表的节点并不意味着释放其内存，而是将其剔除出链表

5.6 单链表的遍历

遍历的意思就是逐个访问每一个节点，对于线性表而言，由于路径唯一的选择就是从头走到尾。因此 相当而言比较简单。

下面是单向链表的遍历示例代码，假设遍历每个节点并将其整数数据输出：

/*
@function: NODE* slist_find(const NODE* head,DATA data);
@berif: 查找链表数据data
@argument: head: 指向头指针变量
data: 待查找的数据
@return : 成功返回节点的地址
失败返回NULL
*/
NODE* slist_find(const NODE* head,DATA data)
{
const NODE* p = head;
while(p)
{
if(memcmp(&(p -> data),&data,sizeof(DATA)) == 0)
{
return (NODE*)p;
}
p = p -> next;
}
return NULL;
}
/*
@function: void slist_showAll(const NODE* head);
@berif: 遍历链表数据
@argument: head: 指向头指针变量
@return : 无
*/
void slist_showAll(const NODE* head)
{
const NODE* p = head;
while(p)
{
printf("%d ",p -> data);
p = p -> next;
}
printf("\n");
}

5.7 单链表的销毁

由于链表中的各个节点被离散地分布在各个随机的内存空间，因此销毁链表必须遍历每一个节点，释 放每一个节点。

注意：

         销毁链表时，遍历节点要注意不能弄丢相邻节点的指针

示例代码如下：

/*
@function: void slist_destroy(NODE** head);
@berif: 回收链表
@argument: head: 指向头指针变量的地址
@return : 无
*/
void slist_destroy(NODE** head)
{
NODE* p = *head, *q = NULL;
while(p)
{
q = p;
p = p -> next;
free(q);
}
*head = NULL;
}

注意：我们可以使用valgrind进行内存检测，举例：

valgrind ./..

5.8 完整代码 

singleList.h
#ifndef __SINGLELIST_H
#define __SINGLELIST_H
// 头文件
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
typedef int DATA;
typedef struct node
{
DATA data;
struct node *next;
}NODE;
// 链表创建
int slist_create(NODE**,DATA);
// 链表数据添加-头插法
int slist_addHead(NODE** head,DATA data);
// 链表数据添加-尾插法
int slist_addTail(NODE** head,DATA data);
// 链表数据添加-中间插法
int slist_insert(NODE** head,DATA pos,DATA data);
// 链表数据查询
NODE* slist_find(const NODE* head,DATA data);
// 链表数据更新
int slist_update(const NODE* head,DATA old,DATA newdata);
// 链表数据遍历
void slist_showAll(const NODE* head);
// 链表数据删除
int slist_delete(NODE** head,DATA data);
// 链表回收
void slist_destroy(NODE** head);
#endif
singleList.c
#include "singleList.h"
/*
@function: int slist_create(NODE** head,DATA data);
@berif: 创建单项链表
@argument: head: 指向头指针变量的地址，用来接收首节点地址
data: 存储在节点中的数据
@return : 成功返回 0
失败返回 -1
*/
int slist_create(NODE** head,DATA data)
{
NODE* p = (NODE*)malloc(sizeof(NODE));
if(!p)
{
return -1;
}
p -> data = data;
p -> next = NULL;
*head = p;
return 0;
}
/*
@function: int slist_addHead(NODE** head,DATA data);
@berif: 向链表头部插入一个节点数据
@argument: head: 指向头指针变量的地址，用来接收首节点地址
data: 存储在新节点中的数据
@return : 成功返回 0
失败返回 -1
*/
int slist_addHead(NODE** head,DATA data)
{
NODE* p = (NODE*)malloc(sizeof(NODE));
if(!p)
{
return -1;
}
p -> data = data;
p -> next = *head;
*head = p;
return 0;
}
/*
@function: int slist_addTail(NODE** head,DATA data);
@berif: 向链表尾部插入一个节点数据
@argument: head: 指向头指针变量的地址，用来接收首节点地址
data: 存储在新节点中的数据
@return : 成功返回 0
失败返回 -1
*/
int slist_addTail(NODE** head,DATA data)
{
NODE * pNew = (NODE*)malloc(sizeof(NODE));
if(!pNew)
{
return -1;
}
pNew -> data = data;
pNew -> next = NULL;
NODE* p = *head, *q = NULL;
if(!p)
{
*head = pNew;
return 0;
}
while(p)
{
q = p;
p = p -> next;
}
q -> next = pNew;
return 0;
}
/*
@function: int slist_insert(NODE** head,DATA pos ,DATA data);
@berif: 向链表节点值为pos的位置插入一个节点数据data
@argument: head: 指向头指针变量的地址
pos: 插入节点位置的节点数据
data: 存储在新节点中的数据
@return : 成功返回 0
失败返回 -1
*/
int slist_insert(NODE** head,DATA pos,DATA data)
{
NODE *pNew = (NODE*)malloc(sizeof(NODE));
if(!pNew)
return -1;
pNew -> data = data;
pNew -> next = NULL;
NODE *p = *head, *q = NULL;
if(!p)
{
*head = pNew;
return 0;
}
if(memcmp(&(p -> data),&pos,sizeof(DATA)) == 0)
{
pNew -> next = *head;
*head = pNew;
return 0;
}
while(p)
{
if(memcmp(&(p -> data),&pos,sizeof(DATA)) == 0)
{
pNew -> next = p;
q -> next = pNew;
return 0;
}
q = p;
p = p -> next;
}
q -> next = pNew;
return 0;
}
/*
@function: NODE* slist_find(const NODE* head,DATA data);
@berif: 查找链表数据data
@argument: head: 指向头指针变量
data: 待查找的数据
@return : 成功返回节点的地址
失败返回NULL
*/
NODE* slist_find(const NODE* head,DATA data)
{
const NODE* p = head;
while(p)
{
if(memcmp(&(p -> data),&data,sizeof(DATA)) == 0)
{
return (NODE*)p;
}
p = p -> next;
}
return NULL;
}
/*
@function: int slist_update(const NODE* head,DATA old,DATA newdata);
@berif: 更新链表数据old 为 newdata
@argument: head: 指向头指针变量
old: 待更新的节点数据
newdata: 更新后的节点数据
@return : 成功返回 0
失败返回 -1
*/
int slist_update(const NODE* head,DATA old,DATA newdata)
{
NODE* p = NULL;
if(!(p = slist_find(head,old)))
return -1;
p -> data = newdata;
return 0;
}
/*
@function: void slist_showAll(const NODE* head);
@berif: 遍历链表数据
@argument: head: 指向头指针变量
@return : 无
*/
void slist_showAll(const NODE* head)
{
const NODE* p = head;
while(p)
{
printf("%d ",p -> data);
p = p -> next;
}
printf("\n");
}
/*
@function: int slist_delete(NODE** head,DATA data);
@berif: 删除链表中节点值为data的节点
@argument: head: 指向头指针变量的地址
data: 删除节点中的数据
@return : 成功返回 0
失败返回 -1
*/
int slist_delete(NODE** head,DATA data)
{
NODE *p = *head, *q = NULL;
if(!p)
return -1;
if(memcmp(&(p -> data),&data,sizeof(DATA)) == 0)
{
*head = p -> next;
free(p);
return 0;
}
while(p)
{
if(memcmp(&(p -> data),&data,sizeof(DATA)) == 0)
{
q -> next = p -> next;
free(p);
return 0;
}
q = p;
p = p -> next;
}
return -1;
}
/*
@function: void slist_destroy(NODE** head);
@berif: 回收链表
@argument: head: 指向头指针变量的地址
@return : 无
*/
void slist_destroy(NODE** head)
{
NODE* p = *head, *q = NULL;
while(p)
{
q = p;
p = p -> next;
free(q);
}
*head = NULL;
}
main.c
#include "singleList.h"
int main(void)
{
NODE* head = NULL;
if(slist_create(&head,888) < 0)
{
puts("create failed");
return -1;
}
slist_addTail(&head,999);
slist_addTail(&head,222);
slist_addTail(&head,666);
slist_addTail(&head,777);
slist_addHead(&head,555);
slist_insert(&head,888,1024);
slist_showAll(head);
DATA data ;
while(0)
{
#ifdef DELETE
printf("请输入要删除的数据:");
scanf("%d",&data);
if(data == -1)
break;
if(slist_delete(&head,data) < 0)
{
puts("删除失败,请重试");
continue;
}
slist_showAll(head);
#else
NODE *pFind = NULL;
DATA newdata = 512;
printf("请输入要查找的数据:");
scanf("%d",&data);
if(data == -1)
break;
// if(!(pFind = slist_find(head,data)))
if(slist_update(head,data,newdata) == -1)
{
puts("查找的数据不存在,请重试");
continue;
}
//printf("查找数据:%d 内存地址:%p\n",pFind -> data, &(pFind -> data));
slist_showAll(head);
#endif
}
slist_destroy(&head);
puts("====销毁后=====");
slist_showAll(head);
return 0;
}

5.9 链表优缺点

链式存储中，所有节点的存储位置是随机的，他们之间的逻辑关系用指针来确定，跟物理存储位置无 关，因此从上述示例代码可以很清楚看到，增删数据都非常迅速，不需要移动任何数据。另外，又由 于位置与逻辑关系无关，因此也无法直接访问某一个指定的节点，只能从头到尾按遍历的方式一个个 找到想要的节点。简单讲，链式存储的优缺点跟顺序存储几乎是相对的。

总结其特点如下：

优点

        1. 插入、删除时只需要调整几个指针，无需移动任何数据

        2. 当数据节点数量较多时，无需一整片较大的连续内存空间，可以灵活利用离散的内存

        3. 当数据节点数量变化剧烈时，内存的释放和分配灵活，速度快

缺点

        1. 在节点中，需要多余的指针来记录节点之间的关联。

        2. 所有数据都是随机存储的，不支持立即访问任意一个随机数据。

GoDve丨
关注
算法数据结构学习笔记-C语言.zip
06-14
总的来说，《算法数据结构学习笔记-C语言》是一份全面的学习资源，适合想要掌握C语言和算法数据结构的初学者。通过系统学习和反复练习，你将能够熟练运用C语言来实现复杂的数据结构和高效的算法，为未来的编程生涯...
第1讲-C语言概述.ppt
11-15
C语言是典型的面向过程语言，它强调算法和数据结构的结合。 - 面向对象编程（Object-Oriented Programming, OOP）：以对象为核心，对象包含了数据和操作数据的方法。虽然C语言本身不是完全的面向对象语言，但通过...
商业编程-源码-C语言入门教程.zip
06-21
C语言是一种广泛应用于系统开发、软件工程、嵌入式编程等多个领域的高级编程语言。它的语法简洁、灵活性高，是许多程序员学习编程的第一步。本压缩包"商业编程-源码-C语言入门教程.zip"提供了丰富的资源，帮助初学者...
商业编程-源码-C语言习题与答案.zip
06-21
C语言提供了创建复杂数据结构（如数组、链表、树等）的工具。通过练习，你可以学会如何实现和操作这些数据结构，并配合合适的算法解决实际问题。算法是编程的核心，掌握排序、查找、图论等基本算法对任何程序员都至...
商业源码-编程源码-C语言基础教程.zip
06-14
C语言是一种广泛应用于系统开发、软件工程和嵌入式系统的高级编程语言，它的设计目标是简洁、高效且可移植性强。这个"商业源码-编程源码-C语言基础教程.zip"压缩包很可能是为了帮助初学者和专业人士深入理解C语言的...
理解C语言之深入理解指针（四）
do_yo的博客
10-01 1225
如果你把函数的指针（地址）作为参数传递给另⼀个函数，当这个指针被⽤来调⽤其所指向的函数 时，被调⽤的函数就是回调函数。第13讲中我们写的计算机的实现的代码中，红⾊框中的代码是重复出现的，其中虽然执⾏计算的逻辑 是区别的，但是输⼊输出操作是冗余的，有没有办法，简化⼀些呢？因为红⾊框中的代码，只有调⽤函数的逻辑是有差异的，我们可以把调⽤的函数的地址以参数的形式 传递过去，使⽤函数指针接收，函数指针指向什么函数就调⽤什么函数，这⾥其实使⽤的就是回调函 数的功能。回调函数就是⼀个通过函数指针调⽤的函数。
C语言 | Leetcode C语言题解之第452题用最少数量的箭引爆气球
m0_59237910的博客
10-03 587
C语言 | Leetcode C语言题解之第452题用最少数量的箭引爆气球
2024-09-27 buildroot C和语言将 中文的GBK编码转换为 UTF-8 的代码， printf 显示出来，使用 iconv 库去实现。
海月汐辰
09-27 238
【代码】2024-09-27 buildroot C和语言将 中文的GBK编码转换为 UTF-8 的代码， printf 显示出来，使用 iconv 库去实现。
c primer plus---例程程序纠正
zy_666_king的博客
09-28 236
c primer plus中14.15的例程程序，有错，不能显示正确程序效果。
Raspberry Pi3B+之C/C++开发环境搭建
lida2003的专栏
10-03 536
上述是一个Linux的C/C++应用最为基础的工程。在此基础上，根据项目要求进行功能、特性的开发。
68.【C语言】动态内存管理(重点)(1)
2401_85828611的博客
10-03 547
本文为数据结构打下基础,备注:数据结构需要掌握指针,结构体和动态内存管理。
Ascend C 自定义算子开发：高效的算子实现
Byyyi耀的博客
10-03 304
Ascend C 自定义算子开发：高效的算子实现
数据结构_2.2、顺序表插入删除查找
cfy2401926342的博客
09-29 366
线性表：是具有相同数据类型的n （n≥0）个数据元素的有限序列顺序表：用顺序存储的方式实现线性表顺序存储：把逻辑上相邻的元素存储在物理 位置上也相邻的存储单元中，元素之间的关 系由存储单元的邻接关系来体现。ElemType ：就是你的顺序表中存放的数据元素类型。
数据结构（栈和队列的实现）
2301_80475151的博客
09-30 1070
这里介绍了栈的实现和队列的实现，还有栈和队列的OJ题例如用栈实现队列和用队列实现栈等‘；
Java.数据结构.TreeSet
最新发布
TJKFYY的博客
10-03 153
TreeSet是Java集合框架中的一部分，是基于TreeMap实现的。TreeSet保证了集合中的元素按照自然顺序或者通过提供的Comparator进行排序。：TreeSet会根据元素的自然顺序进行排序，确保集合中的元素总是处于有序状态，和TreeMap一样，我们同样可以通过重写Comparator方法来进行排序。：TreeSet中的元素是唯一的，不能重复。如果有两个元素相等，则后插入的元素不会出现在集合中。：TreeSet基于TreeMap实现，其时间复杂度为O(log n)。
【笔记】选择题笔记+数据结构笔记
m0_52024881的博客
09-30 572
连通分量是极大连通子图一个连通图的生成树是一个极小连通子图。
数据结构——初识树和二叉树
weixin_74209413的博客
09-26 1159
树是由根和子树组成，子树又是由子树的根和子树的子树组成，是一个递归的（嵌套的）结构。示意图如下：树的其他表现方式为何要重点研究每结点最多只有两个的树?二叉树的结构最简单，规律性最强;可以证明，所有树都能转为唯一对应的二又树，不失一般性。普通树(多又树)若不转化为二又树，则运算很难实现二叉树在树结构的应用中起着非常重要的作用，因为对二叉的许多操作算法简单，而任何树都可以与二叉树相互转换，这样就解决了树的存储结构及其运算中存在的复杂性。二叉树。
数据结构（链表的操作算法）
m0_61903191的博客
09-30 420
编写一个程序exp2_2.cpp,采用单链表表示集合(假设同一个集合中不存在重复素)，将其按递增方式排序，构成有序单链表，并求这样的两个集合的并、交和差。(2)依次采用尾插法插入a、b、c、d、e元素。(8)在第4个元素位置上插人1元素。(10)删除单链表h的第3个元素。(6)输出单链表h的第3个元素。(5)判断单链表h是否为空。(4)输出单链表h长度。(7)输出元素a的位置。(1)初始化单链表h。(11)输出单链表h。(12)释放单链表h。(3)输出单链表h。(9)输出单链表h。
【数据结构】栈和队列
2401_84538476的博客
09-28 397
栈和队列是两种重要的线性结构。本章讨论栈和队列的定义、表示方法。这里栈和队列分别用数组实现和链表实现（这里所说是实现的底层逻辑分别是数组结构和链表结构）
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值