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

于 2024-08-29 20:18:16 发布
阅读量264 收藏 2
点赞数 11
文章标签： c语言 数据结构 算法 开发语言 linux 链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/MaBaB/article/details/141686951
版权

双向链表

概念

对链表而言，双向均可遍历是最方便的，另外首尾相连循环遍历也可大大增加链表操作的便捷性。因 此，双向循环链表，是在实际运用中是最常见的链表形态。

基本操作

 与普通的链表完全一致，双向循环链表虽然指针较多，但逻辑是完全一样。基本的操作包括：

1. 节点设计

2. 初始化空链表

3. 增删节点

4. 链表遍历

5. 销毁链表

节点设计

双向链表的节点只是比单向链表多了一个前向指针。示例代码如下所示：

typedef int DATA;
typedef struct node
{
// 以整型数据为例
DATA data;
// 指向相邻的节点的双向指针
struct node *prev;
struct node *next;
}NODE;

 初始化

所谓初始化，就是构建一条不含有效节点的空链表。

以带头结点的双向循环链表为例，初始化后，其状态如下图所示：

 

在初始空链表的情况下，链表只有一个头结点，下面是初始化示例代码： 

int dlist_create(NODE** head,DATA data)
{
// 创建新节点（申请内存空间）
NODE *pNew = (NODE*)malloc(sizeof(NODE));
if(!pNew)
return -1;
// 给节点赋初值
pNew -> data = data;
// 前后指针默认都指向NULL
pNew -> prev = pNew -> next = NULL;
// 将新节点作为头节点
*head = pNew;
return 0;
}

 插入节点

与单链表类似，也可以对双链表中的任意节点进行增删操作，常见的有所谓的头插法、尾插法等， 即：将新节点插入到链表的首部或者尾部，示例代码是：

 头插法：将新节点插入到链表的头部

// 将新节点pNew，插入到链表的首部
int dlist_addHead(NODE** head,DATA data)
{
// 创建新节点并申请内存
NODE *pNew = (NODE*)malloc(sizeof(NODE));
if(!pNew)
return -1;
// 给新节点赋值
pNew -> data = data;
pNew -> prev = NULL;
// 后针指向头指针
pNew -> next = *head;
// 如果头指针存在
if(*head)
// 头指针的前指针指向新节点
(*head) -> prev = pNew;
// 新插入的节点作为新的头节点
*head = pNew;
return 0;
}

尾插法：将新节点插入到链表的尾部

// 将新节点pNew，插入到链表的尾部
int dlist_addTail(NODE** head,DATA data)
{
// 创建节点并申请内存
NODE *pNew = (NODE*)malloc(sizeof(NODE));
if(!pNew)
return -1;
// 初始化节点
pNew -> data = data;
pNew -> prev = NULL;
pNew -> next = NULL;
// 用来记录尾节点，默认头节点就是尾节点
NODE* p = *head;
if(!p)
{
// 头节点不存在，新插入的节点作为头节点
*head = pNew;
return 0;
}
// 通过循环，查找尾节点
while(p -> next)
{
p = p -> next;
}
// 尾节点的后指针指向新插入的节点
p -> next = pNew;
// 新插入的节点的前指针指向尾节点
pNew -> prev = p;
// 此时的新节点作为了新的尾节点
return 0;
}

中间插法：将新节点插入到链表的指定位置

// 将新节点pNew，插入到链表的指定位置
int dlist_insert(NODE** head,DATA pos,DATA data)
{
NODE *pNew = (NODE*)malloc(sizeof(NODE));
if(!pNew)
return -1;
pNew -> data = data;
pNew -> prev = NULL;
pNew -> next = NULL;
NODE* p = *head, *q = NULL;
if(!p)
{
*head = pNew;
return 0;
}
if(memcmp(&(p -> data),&pos,sizeof(DATA)) == 0)
{
pNew -> next = p;
p -> prev = pNew;
*head = pNew;
return 0;
}
while(p)
{
if(memcmp(&(p -> data),&pos,sizeof(DATA)) == 0)
{
pNew -> next = p;
pNew -> prev = q;
p -> prev = pNew;
q -> next = pNew;
return 0;
}
q = p;
p = p -> next;
}
q -> next = pNew;
pNew -> prev = q;
return 0;
}

剔除节点

注意，从链表中将一个节点剔除出去，并不意味着要释放节点的内容。当然，我们经常在剔除了一个 节点之后，紧接着的动作往往是释放它，但是将“剔除”与“释放”两个动作分开，是最基本的函数封装的 原则，因为它们虽然常常连在一起使用，但它们之间并无必然联系，例如：当我们要移动一个节点的 时候，实质上就是将“剔除”和“插入”的动作连起来，此时就不能释放该节点了。

在双向链表中剔除指定节点的示例代码如下：

// 将data对应的节点从链表中剔除
int dlist_delete(NODE** head,DATA data)
{
NODE* p = *head;
if(!p)
return -1;
if(memcmp(&(p -> data),&data,sizeof(DATA)) == 0)
{
if(p -> next == NULL)
{
*head = NULL;
free(p);
return 0;
}
*head = p -> next;
p -> next -> prev = NULL;
free(p);
return 0;
}
while(p)
{
if(memcmp(&(p -> data),&data,sizeof(DATA)) == 0)
{
p -> prev -> next = p -> next;
if(p -> next == NULL)
p -> prev -> next = NULL;
else
p -> next -> prev = p -> prev;
free(p) ;
return 0;
}
p = p -> next;
}
return -1;
}

链表的遍历

对于双向循环链表，路径可以是向后遍历，也可以向前遍历。

下面是根据指定数据查找节点，向前、向后遍历的示例代码，假设遍历每个节点并将其整数数据输 出：

// 根据指定数据查找节点
NODE* dlist_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;
}
// 向前|向后遍历
void dlist_showAll(const NODE* head)
{
const NODE* p = head;
while(p)
{
printf("%d ",p -> data);
p = p -> next;// 向后遍历
// p = p -> prev;// 向前遍历
}
printf("\n");
}

修改链表

我们也可以针对链表中的数据进行修改，只需要提供一个修改的源数据和目标数据即可。 示例代码如下：

int dlist_update(const NODE* head,DATA old,DATA newdata)
{
NODE* pFind = NULL;
if(pFind = dlist_find(head,old))
{
pFind -> data = newdata;
return 0;
}
return -1;
}

销毁链表

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

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

示例代码如下： 

void dlist_destroy(NODE** head)
{
NODE *p = *head, *q = NULL;
while(p)
{
q = p;
p = p -> next;
free(q);
}
*head = NULL;
}

完整案例

dlist.h
#ifndef __DLIST_H
#define __DLIST_H
typedef int DATA;
typedef struct node
{
DATA data;
struct node *prev;// 前驱指针
struct node *next;// 后继指针
}NODE;
// 创建链表（初始化）
int dlist_create(NODE**,DATA);
// 向链表插入数据（头插法）
int dlist_addHead(NODE** head,DATA data);
// 向链表插入数据（尾插法）
int dlist_addTail(NODE** head,DATA data);
// 向链表插入数据（中间插法）
int dlist_insert(NODE** head,DATA pos,DATA data);
// 链表数据查询
NODE* dlist_find(const NODE* head,DATA data);
// 链表数据更新
int dlist_update(const NODE* head,DATA old,DATA newdata);
// 链表数据遍历
void dlist_showAll(const NODE* head);
// 链表数据删除
int dlist_delete(NODE** head,DATA data);
// 链表回收
void dlist_destroy(NODE** head);
#endif
dlist.c
#include "dlist.h"
#include <stdlib.h>
#include <string.h>
#include <stdio.h>
int dlist_create(NODE** head,DATA data)
{
NODE *pNew = (NODE*)malloc(sizeof(NODE));
if(!pNew)
return -1;
pNew -> data = data;
pNew -> prev = pNew -> next = NULL;
*head = pNew;
return 0;
}
int dlist_addHead(NODE** head,DATA data)
{
NODE *pNew = (NODE*)malloc(sizeof(NODE));
if(!pNew)
return -1;
pNew -> data = data;
pNew -> prev = NULL;
pNew -> next = *head;
if(*head)
(*head) -> prev = pNew;
*head = pNew;
return 0;
}
int dlist_addTail(NODE** head,DATA data)
{
NODE *pNew = (NODE*)malloc(sizeof(NODE));
if(!pNew)
return -1;
pNew -> data = data;
pNew -> prev = NULL;
pNew -> next = NULL;
NODE* p = *head;
if(!p)
{
*head = pNew;
return 0;
}
while(p -> next)
{
p = p -> next;
}
p -> next = pNew;
pNew -> prev = p;
return 0;
}
int dlist_insert(NODE** head,DATA pos,DATA data)
{
NODE *pNew = (NODE*)malloc(sizeof(NODE));
if(!pNew)
return -1;
pNew -> data = data;
pNew -> prev = NULL;
pNew -> next = NULL;
NODE* p = *head, *q = NULL;
if(!p)
{
*head = pNew;
return 0;
}
if(memcmp(&(p -> data),&pos,sizeof(DATA)) == 0)
{
pNew -> next = p;
p -> prev = pNew;
*head = pNew;
return 0;
}
while(p)
{
if(memcmp(&(p -> data),&pos,sizeof(DATA)) == 0)
{
pNew -> next = p;
pNew -> prev = q;
p -> prev = pNew;
q -> next = pNew;
return 0;
}
q = p;
p = p -> next;
}
q -> next = pNew;
pNew -> prev = q;
return 0;
}
int dlist_delete(NODE** head,DATA data)
{
NODE* p = *head;
if(!p)
return -1;
if(memcmp(&(p -> data),&data,sizeof(DATA)) == 0)
{
if(p -> next == NULL)
{
*head = NULL;
free(p);
return 0;
}
*head = p -> next;
p -> next -> prev = NULL;
free(p);
return 0;
}
while(p)
{
if(memcmp(&(p -> data),&data,sizeof(DATA)) == 0)
{
p -> prev -> next = p -> next;
if(p -> next == NULL)
p -> prev -> next = NULL;
else
p -> next -> prev = p -> prev;
free(p) ;
return 0;
}
p = p -> next;
}
return -1;
}
NODE* dlist_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;
}
int dlist_update(const NODE* head,DATA old,DATA newdata)
{
NODE* pFind = NULL;
if(pFind = dlist_find(head,old))
{
pFind -> data = newdata;
return 0;
}
return -1;
}
void dlist_destroy(NODE** head)
{
NODE *p = *head, *q = NULL;
while(p)
{
q = p;
p = p -> next;
free(q);
}
*head = NULL;
}
void dlist_showAll(const NODE* head)
{
const NODE* p = head;
while(p)
{
printf("%d ",p -> data);
p = p -> next;
}
printf("\n");
}
dlist_main.c
#include "dlist.h"
#include <stdio.h>
#define OP 2
int main(void)
{
NODE* head = NULL;
int a[] = {1,3,5,7,9};
int n = sizeof a / sizeof a[0];
register int i = 0;
for(; i < n; i++)
dlist_addTail(&head,a[i]);
dlist_showAll(head);
while(1)
{
#if (OP == 0)
DATA data;
NODE *pFind = NULL;
printf("请输入要查找的数据(-1 退出):");
scanf("%d",&data);
if(data == -1)
break;
if(!(pFind = dlist_find(head,data)))
{
puts("查找的数据不存在,请重试...");
continue;
}
printf("在内存地址为 %p 的内存空间中找到了 %d\n",&(pFind->data),pFind->data);
#elif (OP == 1)
DATA data;
NODE *pFind = NULL;
printf("请输入要插入位置的数据(-1 退出):");
scanf("%d",&data);
if(data == -1)
break;
if(dlist_insert(&head,data,407))
{
puts("插入失败,请重试...");
continue;
}
dlist_showAll(head);
#else
DATA data;
NODE *pFind = NULL;
scanf("%d",&data);
if(data == -1)
break;
if(dlist_delete(&head,data))
{
puts("删除失败,请重试...");
continue;
}
dlist_showAll(head);
#endif
}
dlist_destroy(&head);
puts("=====回收后====");
dlist_showAll(head);
return 0;
}

GoDve丨
关注
  • 11
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
算法数据结构学习笔记-C语言.zip
06-14
总的来说，《算法数据结构学习笔记-C语言》是一份全面的学习资源，适合想要掌握C语言和算法数据结构的初学者。通过系统学习和反复练习，你将能够熟练运用C语言来实现复杂的数据结构和高效的算法，为未来的编程生涯...
第1讲-C语言概述.ppt
11-15
C语言是典型的面向过程语言，它强调算法和数据结构的结合。 - 面向对象编程（Object-Oriented Programming, OOP）：以对象为核心，对象包含了数据和操作数据的方法。虽然C语言本身不是完全的面向对象语言，但通过...
嵌入式初学-C语言-数据结构--一
MaBaB的博客
08-27 1140
顺序存储中，由于逻辑关系是用物理位置来表达的，因此从上述示例代码可以很清楚看到，增删数据 都非常困难，需要成片地移动数据。顺序表对数据节点的增删操作是很不友好的。总结其特点如下：优点1. 不需要多余的信息来记录数据间的关系，存储密度高2. 所有数据顺序存储在一片连续的内存中，支持立即访问任意一个随机数据，比如上述顺序表中第 个节点是 s->data[i]缺点1. 插入、删除时需要保持数据的物理位置反映其逻辑关系，一般需要成片移动数据2. 当数据节点数量较多时，需要一整片较大的连续内存空间。
嵌入式初学-C语言-数据结构--二
最新发布
MaBaB的博客
08-28 844
单链表 5.1 基本概念 顺序表：顺序存储的线性表。 链式表：链式存储的线性表，简称链表。
嵌入式初学-C语言-十二
MaBaB的博客
08-03 1225
类型说明符 数组名[数组容量]说明：数组的类型说明符由数组中的元素来决定，也就是元素是什么类型，数组就是什么类型数组名也是标识符， 我们所说的数组(名)，大家可以理解为数据类型是数组的变量(名)。数组容量也可以叫做常量表达式，举例： int ages[10]、int lcd[1024*768]类型：代表了数组中元素的类型容量：数组中能存储多少个元素，数组容量可以是一个常量、常量表达式，还可以是符号常量，但必 须是整型。深入理解：定义一个数组，相当于申请了一个可以容纳所指定元素数量的内存单元。
嵌入式初学-C语言-六
MaBaB的博客
07-27 845
我们从磁盘里读取信息，先把读出的数据放在缓冲区，计算机再直接从缓冲区中取数据，等缓 冲区的数据取完后再去磁盘中读取，这样就减少磁盘的读写次数，再加上计算机对缓冲区的操作大大 快于磁盘的操作，故应用缓冲区可大大提高计算机的运行速度
嵌入式初学-C语言-二三
MaBaB的博客
08-14 1067
main函数有多种定义格式，main函数也是函数，函数相关的结论，对main函数也有效（也可以定义main函数的函数指针）
嵌入式初学-C语言-七
MaBaB的博客
07-29 587
分支结构 分支结构：又被称之为选择结构 概念 选择结构：根据条件成立与否，选择相应的操作。
嵌入式初学-C语言-十八
MaBaB的博客
08-08 1302
变量的生命周期的概念：变量在程序运行中存在的时间
嵌入式初学-C语言-二六
MaBaB的博客
08-19 1083
比如：需要管理一个学生对象，只需要定义一个 struct student majie{…}；假如：需要管理多个学生对象，此时就需要一个结构体数组，struct student students[64]第一种：先定义结构体类型，然后定义结构体变量，再将变量存储到结构体数组中定义结构体类型，然后定义结构体数组并初始化第三种：定义结构体类型同时定义数组并初始化第四种：定义结构体类型同时定义结构体数组，然后通过索引给结构体成员赋值结构体数组名访问结构体成员：2.格式：结构体数组名 ->成员名。
嵌入式初学-C语言-十六
MaBaB的博客
08-06 1105
函数定义时，指定的参数，形参是用来接收数据的，函数定义时，系统不会为形参申请内存，只有当函数调用时，系统才会为形参申请内存，用于存储实际参数，并且当函数返回，系统会自动回收，为形参申请的内存资源（本质上所有函数都有return返回，只不过当我们的函数返回类型是void的时候，return关键字被省略了）③ 若使用用户定义的函数，而用户函数又在主调函数的后面，则应在主调函数中对被调用的函数进行声明。1. 函数调用时，主调函数传递的数据参数（常量，变量，表达式，只要有确定的值），实参是传递的数据。
嵌入式初学-C语言-二二
MaBaB的博客
08-13 828
函数指针本质是指针，他是函数的指针（定义一个指针变量，变量中存储了函数的地址）。函数都有一个入口地址，所谓指向函数的指针，就是指向函数的入口地址。这里函数名就代表入口地址。返回值类型（*变量名）(形式参数列表)；举例：本质是函数，这个函数的返回值类型是指针，这个函数称为之指针函数在C语言中，一个函数不仅可以返回整型、字符型、实型等值，也可以返回指针类型的值，即C语言中还允许定义返回指针值的函数，访问了一个已经销毁或者访问受限的内存区域外的指针，这个指针就被称为野指针。
商业编程-源码-C语言入门教程.zip
06-21
C语言是一种广泛应用于系统开发、软件工程、嵌入式编程等多个领域的高级编程语言。它的语法简洁、灵活性高，是许多程序员学习编程的第一步。本压缩包"商业编程-源码-C语言入门教程.zip"提供了丰富的资源，帮助初学者...
商业编程-源码-C语言习题与答案.zip
06-21
C语言提供了创建复杂数据结构（如数组、链表、树等）的工具。通过练习，你可以学会如何实现和操作这些数据结构，并配合合适的算法解决实际问题。算法是编程的核心，掌握排序、查找、图论等基本算法对任何程序员都至...
商业源码-编程源码-C语言基础教程.zip
06-14
3. **基本语法**：包括数据类型（如int、float、char等）、变量、常量、运算符、控制结构（如if-else、switch-case、for、while循环）以及函数的定义和调用。 4. **指针**：C语言的核心特性之一，讲解指针的概念、...
c语言——数组
2301_78693337的博客
08-22 618
例如：随着人工智能的不断发展，基础编程语言这门技术也越来越重要，很多人都开启了学习C语言学习，本文就介绍了C语言数组学习的基础内容。提示：以下是本篇文章正文内容，下面案例可供参考代码如下（示例）：注意：数组下标从0开始int a[5];提示：这里对文章进行总结：例如：以上就是今天要讲的内容，本文仅仅简单介绍了数组的使用，而大量能使我们快速便捷地处理数据的函数和方法。
Python-MNE-源定位和逆问题01：源估计（SourceEstimate）数据结构
weixin_58312922的博客
08-25 675
stc是MNE-Python的一个类，表示从源估计中获得的转换的时间序列。对于两个半球，数据分别存储在和中，储存形式为的形式为一个m*n的矩阵，m是这个半球的空间位置的数量，n是时间点的个数。和对应和。这些是表面表征的位置索引。表面的坐标存储在和中，分别表示左半球和右半球。
排序------快速排序（C语言实现）
markingyi的博客
08-25 852
讲解快速排序原理，并通过例题使用C语言实现。
八股总结-----C++、数据结构、算法
m0_48022770的博客
08-25 336
存储可执行代码（程序指令）。：存储全局变量和静态变量（已初始化和未初始化）。：用于动态内存分配，由程序员管理。：存储函数调用中的局部数据（局部变量、参数、返回地址）。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值