嵌入式全栈开发学习笔记---数据结构（双向链表）

最新推荐文章于 2024-08-07 06:33:20 发布
最新推荐文章于 2024-08-07 06:33:20 发布
阅读量170 收藏 3
点赞数 3
分类专栏： 嵌入式全栈开发学习笔记 文章标签： 数据结构 单片机 嵌入式硬件 stm32 QT Linux C/C++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xiaobaivera/article/details/140970936
版权

目录

双向链表的定义

双向链表的初始化

双向链表的插入操作

双向链表的删除操作

完整代码

Link.c

Link.h

Main.c

本节开始学习双向链表！

我们先复制前面讲单链表的那个目录。

补充命令11：cp -rf （recursive、force）递归强制拷贝文件，如下，将linklist文件夹下的文件复制到doublelink文件夹下

将linklist文件夹下的文件复制到doublelink文件夹下后，链表的初始化、链表插入、链表的删除操作操作需要修改，其他的都不用改。其中链表的反转函数可以注释掉，因为双向链表不需要反转操作。

双向链表的定义

因为双向链表有两个指针域，所以link.h中表示结点的结构体需要修改为：

双向链表的初始化

然后link.c中链表的初始化函数需要修改为：

双向链表的插入操作

双向链表要插入节点时，前一个结点的next要改成被插入节点的地址，被插入节点的prior要填入前一个结点的地址，被插入节点的next要填入后一个结点的地址，而后一个结点的prior要填入被插入节点的地址。

在link.c中修改链表插入函数

双向链表的删除操作

比如我们要删除第二个节点，在删除之前我们得先把第三个结点的位置存放在第一个结点的next指针域中，然后将第一个结点的位置存放在第三个结点的prior指针域中，最后再释放掉第二个节点的空间。

在link.c中加上这一句

运行结果：

完整代码

Link.c

#include "link.h"
#include <stdlib.h>//malloc的头文件
#include <stdio.h>//printf的头文件

//链表的初始化
int init_link(Node **h)//用指针接收指针的地址
{
	if(NULL==h)//判断空指针
	{
		return FAILURE;
	}
	*h=(Node*)malloc(sizeof(Node)*1);//头指针的地址存在h里面，则*h=head(头指针），在头指针指向的位置申请空间
	if(NULL==(*h))//如果返回值是空的话说明内存用完了
	{
		return FAILURE;
	}
	(*h)->next=NULL;//头节点的后面一个指针域初始化为空
	(*h)->prior=NULL;//头节点的前面一个指针域初始化为空
	return SUCCESS;

}

//链表的插入操作
int insert_link(Node*h,int p,int n)//p接收的是要插入的位置
{
	//入参判断
	if(NULL==h)
	{
		return FAILURE;
	}
	
	Node *q=h;//q指向头节点
	int k=1;//记录下移动的次数
	while(k<p && q)//保证移动的次数小于p,并且要保证q不等于NULL，因为当p不合法时，比如p大于链表的长度＋1，那q=q->next有可能给q赋值了NULL，导致程序死掉	
	{
		q=q->next;//把q指针移动到要插入位置的前一个位置,此时q指向第一个节点
		k++;//k++后就不小于p了，退出循环
	}

	//判断位置是否合法
	if(q==NULL||k>p)//位置太大或者位置太小(比如p=0)都不合法
	{
		return FAILURE;
	}

	Node *m=(Node*)malloc(sizeof(Node)*1);//申请节点

	if(NULL==m)
	{
		return FAILURE;//内存不足，申请失败
	}
	
	m->data=n;//将num存放在数据域
	m->next=q->next;//将第一个节点的指针域里面存放的地址搬到此节点的指针域
	m->prior=q;//将q所指向的地址（第一个节点的位置）赋值给m的prior
	if(q->next)//考虑到尾插法的情况，当q->next不为空说明不是尾插法
	{
		q->next->prior=m;//将m赋值给原来第二个节点的prior指针域
	}
	q->next=m;//将m赋值给第一个节点的next指针域

	return SUCCESS;
}


//遍历链表
void traverse_link(Node*h,void (*p)(int))//结构体指针，和函数指针(接收时要指明返回值和参数）
{
	//入参判断
	if(NULL==h)
	{
		return;//程序不会向下走了
	}
	
	Node *q=h->next;//q指向第一个节点
	while(q)//只要q不为空
	{
		p(q->data);//由于p指向show函数，可以通过p调用show函数
		q=q->next;//q继续指向下一个节点
	}
}


//判断链表是否为空
int empty_link(Node*h)
{
	if(NULL==h)
	{
		return FAILURE;//这里是失败是因为传的参数错了
	}

	return (h->next==NULL)? SUCCESS:FAILURE;//如果是SUCCESS表示链表为空

}

//判断链表的长度
int length_link(Node*h)
{
	if(NULL==h)
	{
		return FAILURE;//这里失败是因为传的参数错了
	}

	Node*q=h->next;//让q指向第一个节点
	int length=0;
	while(q)//只要q不为空
	{
		length++;//累计
		q=q->next;//q指向下一个节点
	}
	//q为空时退出
	return length;

}

//链表查找操作
int find_link(Node*h,int n,int *r)
{
	if(NULL==h||NULL==r)
	{
		return FAILURE;
	}
 
	Node *q=h->next;//让q指向第一个节点
	int i=0,len=0,flag=0;
	while(q)//只要q不为空
	{
		len++;//长度累计
		if(q->data==n)//如果找到n
		{
			r[i++]=len;
			flag=1;//找到
		}
		q=q->next;
	}

	if(flag==1)
	{		
		return SUCCESS;
	}
	else
	{
		return FAILURE;
	}
}

/*
//链表反转操作
int reverse_link(Node*h)
{
	if(NULL==h)
		return FAILURE;

	Node *p=h->next;//让p指向第一个节点
	h->next=NULL;//让头节点的指针域为空
	
	while(p)
	{
		Node*q=p;//让q也指向第一个节点
		p=p->next;//让p指向第二个节点
		q->next=h->next;//让q即第一个节点的指针域为空
		h->next=q;//把第一个节点的位置放到头节点的指针域中，即让h指向第一个节点
	}
    
	return SUCCESS;
}
*/

//链表删除操作
int delete_link(Node*h,int p,int *num)
{
	//入参判断
	if(NULL==h||NULL==num)
	{
		return FAILURE;
	}

	Node *q=h;//q指向头节点
	int k=1;//记录下移动的次数
	while(k<p && q)//保证移动的次数小于p,并且要保证q不等于NULL，因为当p不合法时，比如p大于链表的长度＋1，那q=q->next有可能给q赋值了NULL，导致程序死掉	
	{
		q=q->next;//把指针移动到要删除位置的前一个位置，即此时q指向第一个节点
		k++;//k++后就不小于p了，退出循环
	}

	//判断位置是否合法
	if(q==NULL||k>p||q->next==NULL)//位置太大或者位置太小(比如p=0)都不合法,当q->next指向的位置为NULL，就不合法，因为不能后面没有节点需要删除
	{
		return FAILURE;
	}
	
	//在释放掉p这个空间之前，先把它指针域中存放的下一个节点的地址挪到前一个节点的指针域中
	Node*n=q->next;//此时q指向的是第一个节点，将第二个节点的位置存放在n中，n指向第二个节点
	q->next=n->next;//将第三个节点的位置存放在第一个节点的next指针域中
	if(n->next)//如果n->next即第三个节点不为空，则需要操作第三个节点的prior指针域，如果为空，即第三个节点不存在，也就不需要操作它的prior指针域了
	{
		n->next->prior=q;//将第一个节点的位置存放在第三个节点的prior指针域中
	}
	*num=n->data;//将第二个节点的数据赋值给num,即要删除的数据
	free(n);//释放第二个节点
	return SUCCESS;

}


//判断前驱
int prior_link(Node*h, int num, int*p)
{
	//入参判断
	if(NULL==h||NULL==p)
	{
		return FAILURE;
	}
	
	//判断一下，如果是空链表或者只有一个节点的话肯定不存在前驱
	if(NULL==h->next||NULL==h->next->next)//h->next是第一个节点，h->next->next是第一个节点的指针域
	{
		return FAILURE;
	}
	
	Node *k=h->next;//让k指向第一个节点
	Node *q=k->next;//让q指向第二个节点
	while(q)//只要q不为空
	{
		if(q->data==num)//如果找到
		{
			*p=k->data;//记录下前驱
			return SUCCESS;
		}

		q=q->next;//如果还没有找到，q继续往后走
		k=k->next;//k也继续走
	}

    //如果当q等于NULL,退出while循环了还没有找到
	return FAILURE;
}

//链表清空操作
int clear_link(Node*h)
{
	//入参判断
	if(NULL==h)
	{
		return FAILURE;
	}

	Node*q=h->next;//让q指向第一个节点
	while(q)//只要q不为空
	{
		//释放q之前，先将指针域修改
		h->next=q->next;//将第三个节点的地址存放到头节点
		free(q);//释放第一个节点
		q=h->next;//q指向第二个节点
	}
	return SUCCESS;
}

//链表销毁操作
int destroy_link(Node **h)//接收指针的地址
{
	//入参判断
	if(NULL==h)
	{
		return FAILURE;
	}
	//注意：在销毁操作前必须进行清空操作
	if((*h)->next!=NULL)//说明头指针不为空，说明还没有执行清空操作
	{
		return FAILURE;
	}

	free(*h);//释放头节点所在的位置
	*h=NULL;
	return SUCCESS;
}

Link.h

#ifndef _LINK_H
#define _LINK_H

#define SUCCESS 1000
#define FAILURE 1001

//表示节点的结构体
typedef struct node
{
	int data;
	struct node *next;
	struct node *prior;//多加一个指针指向前面一个节点

}Node;//将结构体重命名为Node


int init_link(Node **h);
int insert_link(Node*h,int p,int n);
void traverse_link(Node*h,void (*p)(int));
int empty_link(Node*h);
int length_link(Node*h);
int find_link(Node*h,int n,int *r);
//int reverse_link(Node*h);
int delete_link(Node*h,int p,int *num);
int prior_link(Node*h, int num, int*p);
int clear_link(Node*h);
int destroy_link(Node **h);
#endif

Main.c

#include <stdio.h>
#include "link.h"
#include <stdlib.h>
#include <time.h>//设置随机数的头文件


void show(int x)
{
	printf("%d ",x);
}


int main()
{
	//定义一个头指针
	Node *head=NULL;

	//初始化链表
	int ret=init_link(&head);
	if(SUCCESS==ret)//如果返回值是SUCCESS
	{
		printf("链表初始化成功\n");
	}
	else
	{
		printf("链表初始化失败\n");
	}


	srand(time(NULL));//设置种子，记得包含头文件time.h
	//插入元素
	int i,num;
	for(i=0;i<10;i++)//插入10个元素
	{
		num=rand()%20+1;//插入随机数,数字范围在0～20
		ret=insert_link(head,i+1,num);//这种插入的方式就像一个尾插法，head是头指针，头指针存放的是链表头节点的地址，也相当于链表的位置，类似数组名的作用
		if(SUCCESS==ret)
		{
			printf("在第%d个位置插入%d成功\n",i+1,num);
		}
		else
		{
			printf("插入%d失败\n",num);
		}
	}

	//遍历链表
	traverse_link(head,show);//将头指针传过去，类似传数组名,将函数名show（即函数的地址）也传过去
	printf("\n");//换行

	//判断链表是否为空
	ret=empty_link(head);
	if(SUCCESS==ret)
	{
		printf("链表为空\n");
	}
	else
	{
		printf("链表不为空\n");
	}

	//判断链表的长度
	printf("链表的长度是%d\n",length_link(head));

	//链表查找操作
	num=rand()%20+1;//随机生成一个数
	int res[10]={0};//用来存放num的所有节点的位置
	ret=find_link(head,num,res);
	if(SUCCESS==ret)
	{
		printf("%d 出现的位置是  ",num);
		for(i=0;i<10 && res[i]!=0;i++)
		{
			printf("%d",res[i]);
		}
		printf("\n");
	}
	else
	{
		printf("%d不存在\n",num);  
	}
/*
	//反转链表
	reverse_link(head);
	//遍历链表,验证反转的结果
	traverse_link(head,show);//将头指针传过去，类似传数组名,将函数名show（即函数的地址）也传过去
	printf("\n");//换行
*/

	//链表的删除
	int p;//用来保存删除的位置
	for(i=0;i<5;i++)//删除5个节点
	{
		p=rand()%15;
		ret=delete_link(head,p,&num);//p是要删除的位置，num是要删除的数
		if(SUCCESS==ret)
		{
			printf("删除第%d个元素成功 %d\n",p,num);
		}
		else
		{
			printf("删除第%d个元素失败\n",p);
		}
	}


	//遍历链表,验证删除的结果
	traverse_link(head,show);//将头指针传过去，类似传数组名,将函数名show（即函数的地址）也传过去
	printf("\n");//换行

	//判断链表的前驱
	int prior;
	num=rand()%30;
	ret=prior_link(head,num,&prior);
	if(SUCCESS==ret)
	{
		printf("元素%d的前驱是%d\n",num,prior);
	}
	else
	{
		printf("元素%d不存在前驱\n",num);
	}

	//链表清空操作
	ret=clear_link(head);
	if(SUCCESS==ret)
	{
		printf("链表清空成功\n");
	}
	else
	{
		printf("链表清空失败\n");	
	}

	//遍历链表,验证清空的结果
	traverse_link(head,show);//将头指针传过去，类似传数组名,将函数名show（即函数的地址）也传过去
	printf("\n");//换行

	//链表销毁操作
	ret=destroy_link(&head);	
	if(SUCCESS==ret)
	{
		printf("链表销毁成功\n");
	}
	else
	{
		printf("链表销毁失败\n");	
	}



	return 0;
}

下节开始讲双向循环链表！

QQ交流群：963138186

本篇就到这里，下篇继续！欢迎点击下方订阅本专栏↓↓↓

Vera工程师养成记
关注
  • 3
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
计算机考研（知识点碎片）
scxe_voz的博客
10-25 256
HTTPS，数据加密HTTP升级版，缺省端口443。IMAP，交互式邮件存取协议，缺省端口143。HTTP，超文本传输协议，缺省端口80。POP3，邮件接收协议，缺省端口110。SMTP，邮件发送协议，缺省端口25。
嵌入式全栈开发学习笔记---数据结构（链表的分类）
xiaobaivera的博客
08-06 104
常见的链表有：静态链表（用的很少，有点类似于顺序表）、单链表、双向链表、循环链表、双向循环链表（效率最高）
嵌入式全栈开发学习笔记---数据结构（双向循环链表）
最新发布
xiaobaivera的博客
08-07 323
​双向循环链表同时具有双向链表和循环链表的特性，是效率最高的一种链表。我们也是在单链表的代码基础上修改。 双向循环链表的初始化 在双向循环链表中，从头到尾我们都不能出现NULL这个字眼。 初始化的时候，头结点的Prior和next指针域都初始化为它自己的地址。
嵌入式从硬件到Linux学习经验汇总-----By知乎
woshizuopie的博客
03-10 7666
目录 一．作者：懒懒土拨鼠 第一阶段称为stm32+RTOS阶段。 第二阶段称为多核+Linux阶段。 第三阶段 最后荐书环节 二．作者：程序员良许 转折点 入门 新挑战 Linux应用的学习 1.环境搭建 2.基本操作 3.系统编程 4.网络编程 5.数据库编程 6.Shell编程 Linux应用编程书籍推荐： 三。作者：DiedCode 1，学习单片机： 2，过渡 3，看ucos（非必须） 4，Linux应用编程 把握以下几点： 5，嵌入式Linux 6
2021-09-09
我是一只蘑菇17的博客
09-09 560
金九银十，狂热的招聘季在悄声无息间开始了，小编也去尝试了一波，被杀的体无完肤，面试官问的和我想的根本不在一个节拍，现在就将最近失败的面试经历分享给大家，全搞懂的话，相当于你接到了5个offer，很负责任的告诉大家，这些都是我在面试过程中，面试官问我的，如果我先总结了这篇文章，结果一定会大相径庭。 目录 1、实例化对象有哪几种方式 2、你用过单点登录吗？是如何实现的？ 3、说一下什么是Spring IOC...
【八股】2024春招八股复习笔记3（测试、运维、安全、游戏、客户端）
小哈里的博客
03-27 2773
1、测试开发 2、运维开发 SRE 3、安全开发 4、运营开发/应用开发（全栈） 5、客户端：PC & 移动 & 游戏 我有一个问题，既然测试、运维、安全、运营、客户端都要会开发，同时还要会很多专业领域的知识，但是待遇和职业发展却都远远不如开发。那为什么不直接投业务开发呢（好吧可能是太卷了） 1、测试开发 1、网络 & 系统（含linux） 2、数据库，MySQL，JAVA 3、测试流程：单元测试、集成测试、系统测试 【八股】2024春招八股复习笔记3（测试、运维、安全、游戏、客户端）
2023届嵌入式笔面经&一位双非本科生的秋招日记
pzslongyutianxia的博客
10-07 6314
该文章是个人在2022年秋季招聘期间总结的一些经验分享，希望这篇文章能够帮助大家成功渡劫秋招，找到自己满意的工作，拿到令人心动的Offer!
jvm笔记
miskak的博客
03-08 1627
Java的日常应用开发中 类的加载几乎是由上述三种类加载器相互配合运行的在必要时 我们可以自定义类加载器 来定制类的加载方法为什么要自定义隔离加载类修改类的加载方法扩展加载原防止源码泄漏初步印象以前对内存区理解只有 java堆栈结构栈和堆栈是运行时单位堆是存储的单位是什么。
C++ 学到什么程度可以找工作？
热门推荐
青春不老，奋斗不止！
07-21 1万+
置顶/星标公众号????，硬核文章第一时间送达！链接 |https://www.zhihu.com/question/400543720至少需要哪些知识？需要掌握到什么程度呢？https...
【数据结构】——堆的实现（赋源码）
ZWW_zhangww的博客
08-06 316
堆(Heap)是中一类特殊的，是最高效的。堆通常是一个可以被看作一棵的数组对象。
数据结构系列文章目录
qq_31804097的博客
08-06 389
按章节顺序更新 望三连。
数据结构第九讲：二叉树
2301_79761834的博客
08-03 724
数据结构第九讲：二叉树
顺序表-数据结构
qq_31804097的博客
08-06 74
顺序表是通常是数组，要求数据连续存储。顺序表又分为定长顺序表和变长顺序表，本文实现后者。
数据结构（学习）2024.8.6
何物爱惜雨的博客
08-06 1011
数据结构（数据，逻辑结构，存储结构和操作），算法的相关定义和知识（算法的特性，判断标准），时间复杂度，空间复杂度，顺序表（特点，命名规则，相关操作）
数据结构（邓俊辉）学习笔记】词典 03—— 排解冲突(1)
weixin_44399845的博客
08-06 462
学习下词条的排解冲突方法
数据结构：队列（含源码）
2401_86551514的博客
08-06 349
队列是一种只允许在一端进行插入数据操作，在另一端进行删除数据操作的特殊线性表，队列具有先进先出，进行插入操作的一端称为队尾，进行删除操作的一端称为队头，与栈刚好相反，栈时先进后出，队列是先进先出。队列和栈类似，都可以用链表和数组实现，不过有一点不同的是，队列用链表实现会更好一点，因为如果使用数组的结构，出队列在数组头上出数据，效率会比较低，这篇文章就用链表实现。另外了解一下，实际中我们有时还会使用一种队列叫循环队列，生产者消费者模型时可以就会使用循环队列，环形队列可以使用数组实现，也可以使用循环链表实现。
【数据结构】——二叉树OJ题
2302_78420373的博客
08-02 1228
我们先想想二叉树我们学习了哪些内容再来做题哈其实学习二叉树重要的思想——递归，我们可以通过后面的题目慢慢的理解。
【平衡二叉树】数据结构—平衡二叉树
qq_64108165的博客
08-06 336
【数据结构】平衡二叉树
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Vera工程师养成记

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值