数据结构之单链表

[数据结构]链表之单链表 单链表是一种常见的线性数据结构,由若干个节点组成,每个节点包含两部分:数据元素和指向下一个节点的指针。每个节点只有一个指针,通常称为 next 指针,它指向该节点的后继节点。头节点是第一个节点前面额外添加的一个节点,它不包含数据元素,但是包含对第一个节点的指针。单链表可以表示任意长度的序列,可以动态地插入、删除节点,使其具有灵活性和高效性。但由于每个节点只有一个指针,因此单链表只能从前往后遍历,不能反向遍历。以下是单链表常用的操作:创建链表:创建一个空链表,可选是否带有头节点。 阅读详情

Platform:ubuntu , C Language

在一个项目中,数据结构使用的类型不会很多,并且结构一旦稳定,基本都很少对其改动。所以对于我个人而言,数据结构很少用到,但又及其重要。当前的项目使用的是队列,但究其根本,也只不过是操作受限的链表。从简单的单链表开始,做一知识点的整理。如有不足,还请指教!

链表(Linked list)

          链表是通过指针将一组零散的内存块串联在一起。其中,我们把内存块称为链表的“结点”。为了能将所有的结点串起来,每个链表的结点除了存储数据外,还需要记录链表上的下一个结点地址。如下图所示,我们把这个记录下个结点的指针叫作后继指针next。其中有2个结点是比较特殊的,分别是第一个结点(头结点)和最后一个结点(尾结点),头结点记录链表基地址,尾结点指向一个空地址(NULL)。

          相比数组,链表是一中稍微复杂一点的数据结构,也是非常基础、常用的数据结构。

        数组需要一块连续的内存空间来存储,对内存的要求比较高,如果我们申请一个100MB大小的数组,当内存中没有连续的、足够大的存储空间时,即便内存的剩余总可用空间大于100MB,仍会申请失败。(由此拓展malloc等内存函数也是分配连续性的内存空间)。

        而链表恰恰相反,它并不需要一块连续的内存空间,它通过“指针”将一组零散的内存串联起来使用,所以如果我们申请的是100MB大小的链表,根本不会有问题。

       与数组一样,链表也支持数据的查找、插入和删除操作。在数组中,插入、删除操作时,为了保持内存数据的连续性,需要做大量的数据搬移,所以时间复杂度为O(n)。而对于链表,由于存储空间不是连续的,只需要考虑相邻结点的指针改变,所以复杂度为O(1)。

       但是,链表要想访问第k个元素,就没有数组那么高效了,因为链表中的数据并非连续存储的,所以无法像数组一样,根据首地址和下标,通过寻址公式就能直接计算出对应的内存地址,而是根据指针一个结点一个结点的依次遍历,直到找到相应的结点。可以把链表想象成一个队伍,队伍中每个人只知道自己后面的人是谁,所以当我们希望知道排在第k位人是谁,我们就需要从第一个人开始,一个个往下数。所以链表随机访问的性能没有数组好,需要O(n)的时间复杂度。

链表步骤

       1.构建节点的结构(ListNode);

       2.创建头结点(head);

       3.数据操作:插入,删除,遍历操作;

/*****************************************************
*	@FileName 		:	list.c
*	@Creator		:	Donkey
*	@Date 			:	2019-02-13
*	@Description	        :	单向链表实现
*	@Api			:	主要的几个接口
		.init_list 	:	初始化链表
		.insert_list    :	插入数据
		.remove_list    :	删除数据
		.clear_list	:	清除链表
		.Display 	:	遍历链表
******************************************************/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define Debug() printf("[%d %s]\n",__LINE__,__FUNCTION__)
#define DATATYPE int

/* 节点结构 : 根据需求设计数据结构 */
typedef struct node
{
	DATATYPE data;
	struct node * next;	
}ListNode;

/* 初始化 */
int init_list(ListNode *head)
{
	Debug();
	head = (ListNode *)malloc(sizeof(ListNode));
	if(NULL == head)
	{
		printf("malloc failed!\n");
		return 1;
	}
	head->next = NULL;
	return 0;
}
/* 插入 */
int insert_list(ListNode *head,int n)
{
	Debug();

	ListNode * p = head;
	ListNode *d = (ListNode *)malloc(sizeof(ListNode));
	d->data = n;
	d->next = NULL;

	while(p->next != NULL)
	{
		p = p->next;
	}

	p->next = d;
	return 0;
}
/* 删除 */
int remove_list(ListNode * head,int n)
{
	Debug();
	if(NULL == head)
	{
		printf("list is Null\n");
		return 1;
	}
	int flag = 0;
	if(NULL == head)
	{
		printf("list is Null\n");
		return 1;
	}
	ListNode * p = head;
	ListNode * q = head;

	while(p->next != NULL)
	{
		printf("data = %d \n",p->next->data);
		if(p->next->data == n)
		{
			//delete
			flag = 1;
			q = p->next;
			p->next = p->next->next;
			free(q);
			break;
		}
		p = p->next;
	}

	if(flag == 0)
		return 1;

	return 0;
}
/* 清除 */
int clear_list(ListNode *head)
{
	Debug();
	if(NULL == head)
	{
		printf("list is Null\n");
		return 1;
	}
	ListNode *p = head,*q = head;
	p->next = head->next;
	while(p->next != NULL)
	{
		q = p->next;
		p->next = q->next;
		free(q);
	}
	free(p);
	return 0;
}
/* 遍历打印 */
int Display(ListNode *head)
{
	Debug();
	if(NULL == head->next)
	{
		printf("list is Null\n");
		return 0;
	}
	ListNode *p = head;
	p = p->next;

	while(p != NULL)
	{
		printf("%d\t",p->data);
		p = p->next;
	}
	printf("\n");
	return 0;
}

int main(int argc, char const *argv[])
{
	Debug();
	int ret = 0;//return value
	/* init */
	ListNode * test = (ListNode *)malloc(sizeof(ListNode));
	if(NULL == test)
	{
		printf("malloc failed !\n");
		return 1;
	}

	if((ret = init_list(test)) == 1)
	{
		printf("init list failed!\n");
		return 1;
	}
	
	if((ret = insert_list(test,1)) == 1)
	{
		printf("insert list failed!\n");
		return 1;
	}
	if((ret = insert_list(test,10)) == 1)
	{
		printf("insert list failed!\n");
		return 1;
	}
	if((ret = insert_list(test,100)) == 1)
	{
		printf("insert list failed!\n");
		return 1;
	}
	if((ret = insert_list(test,1000)) == 1)
	{
		printf("insert list failed!\n");
		return 1;
	}
	if((ret = insert_list(test,10000)) == 1)
	{
		printf("insert list failed!\n");
		return 1;
	}

	if((ret = Display(test)) == 1)
	{
		printf("Display list failed!\n");
		return 1;
	}
	
	if((ret = remove_list(test,10)) == 1)
	{
		printf("remove list failed!\n");
		return 1;
	}

	if((ret = Display(test)) == 1)
	{
		printf("Display list failed!\n");
		return 1;
	}

	if((ret = clear_list(test)) == 1)
	{
		printf("clear list failed!\n");
		return 1;
	}

	if((ret = Display(test)) == 1)
	{
		printf("Display list failed!\n");
		return 1;
	}
	Debug();

	return 0;
}


执行结果

 

 

补充

1.关于上述涉及到访问数组时,可以根据下标高效的获取地址。

从数组存储的内存模型上来看,“下标”最确切的定义应该是“偏移(offset)”。如果用a来表示数组的首地址,a[0]就是偏移为0的位置,也就是首地址,a[k]就表示偏移k个type_size的位置,所以计算a[k]的内存地址只需要用公式:

a[k]_address = base_address + k * type_size;

可参考文章:https://blog.youkuaiyun.com/localhostcom/article/details/86358593

2.技巧

      1)理解指针或引用的含义

                将某个变量赋值给指针,实际上就是将这个变量的地址赋值给指针,或者反过来说,指针中存储了这个变量的内存地址,指向了这个变量,通过指针就能找到这个变量。

       2)警惕指针的丢失和内存泄漏

                  C语言内存管理是由程序员负责的,如果没有手动释放结点对应的空间,就会产生泄漏,所以我们插入结点时,一定要注意操作的顺序。

       3)利用哨兵简化实现的难度

                 哨兵解决的是国家之间的边界问题,同理这里说的也是解决“边界问题”,不直接参与业务逻辑。我们引用哨兵结点,在任何时候,不管链表是否为空,head指针都会一直指向这个哨兵结点。我们也把这有哨兵结点的链表叫带头链表。相反,没有哨兵结点的链表就叫做不带头链表。

                  哨兵结点是不存储数据的,因为该结点一直存在,所以插入第一个节点和插入其它结点,删除最后一个结点和删除其它结点,都可以统一为相同的代码实现逻辑。

        4)重点留意边界条件处理

                        1>链表为空时,代码是否能正常工作?

                        2>链表只包含一个结点时,代码能否正常工作?

                        3>链表只包含2个结点时,代码能否正常工作?

                        4>代码逻辑在处理头结点和尾结点时,是否能正常工作?

                        5> and so on....

          5)举例画图,辅助思考

             6)多写多练,没有捷径

                    可以5个常见的操作练手:单链表反转,链表中环的检测,两个有序的链表合并,删除链表倒数第n个结点,求链表的中间结点。

 

Java网页访问报错?手把手教你解决JRE插件缺失和浏览器拦截问题(附详细截图) 本文针对Java网页访问时常见的JRE插件缺失和浏览器拦截问题,提供了详细的诊断与解决方案。文章首先解释了问题根源在于现代浏览器出于安全考虑停止了对Java插件的支持,然后手把手指导用户确认Java安装、在控制面板配置安全站点列表,并针对Chrome、Edge、Firefox等主流浏览器的不同拦截机制给出了具体的应对策略,最后提供了系统性的故障排查清单,帮助用户彻底解决访问障碍。 阅读详情

相关推荐

TI电机驱动应用中MOSFET选型完整指南

深入解析TI电机驱动设计中MOSFET的选型关键,涵盖参数匹配、热性能与开关效率,帮助工程师优化系统性能并提升能效,是掌握MOSFET应用的核心参考。

weixin_42263617的博客 1272

链表基础知识和相关操作

一、链表的类型 1.单链表 入口点为链表的头结点(head),链表中每个节点存储该结点的内容(数据)以及下一个节点的指针。 2.双链表 每个节点有两个指针域,一个指向该结点前一节点,另一个指向该结点后一节点,此种链表既可向前查询也可以向后查询。 3.循环链表 即链表首尾相连,可用于解决约瑟夫环问题。 二、链表在内存的存储 数组在内存中是以连续空间存储,链表在内存中并不是连续存储,而是散落分布在内存中,通过指针串联各个节点。 三、链表的定义 struct ListNode{

qq_43697646的博客 1283

408——计算机组成原理(持续更新)

小数点前的0代表正数,1代表负数。

qq_55202378的博客 1724

数据结构:单向链表

单向链表1. 单向链表的实现 1. 单向链表的实现 无头+单向+非循环链表增删查改实现 首先定义接口 #pragma once #include<stdio.h> #include<assert.h> #include<stdlib.h> typedef int STDataType; typedef struct SeqListNode { STDataType data;//存放数据 struct SeqListNode* next;//next指向下一个结点

小陈的博客 526

Gamma变换算法之Matlab&FPGA实现

Gamma映射原理 什么是Gamma曲线 人眼的感光与光强并不是呈线性关系的,而是呈非线性关系(指数型关系,如下图左-曲线。在低照度下,人眼更容易分辨出亮度的变化,随着照度的增加,人眼不易分辨出亮度的变化。而图像传感器与输入光强呈线性关系(如下图左-直线)。从图中可见,当传感器感光在20%左右时,人眼感光响应达到了50%,人眼对低照度的变化更为敏感。从下图右侧可见,Reference Tone为人眼感光50%的亮度,而传感器在感光50%时则相对暗的多(见Select,近似中性灰)。这种将原始图像通过映射操

CrazyBingo的博客 7408

实战复盘:一次绕过WAF的EDUSRC SQL注入漏洞挖掘

本文详细复盘了一次针对教育行业网站的SQL注入漏洞挖掘实战。通过手动信息收集发现可疑点,并利用‘+’号替换空格等技巧,成功绕过WAF(Web应用防火墙)的拦截。文章逐步演示了从判断注入点到手工获取数据结构、最终解密进入后台的完整过程,并总结了手工测试的优势及高级绕过思路,强调了在EDUSRC等授权范围内进行安全测试的重要性。

weixin_28622215的博客 193

c++ listnode 赋值_C++操作单链表ListNode

C++操作单链表ListNode通过C++进行单链表的创建、打印以及利用栈实现逆序打印。单链表的创建和打印#include using namespace std;//定义结构体struct ListNode{int val;ListNode* next;};class operateList{public:/*创建单链表*/void createList(ListNode *head){int ...

weixin_35677043的博客 2120

Framelet Transform

需要定义 Framelet 的基函数。Framelet 基函数可以是通过组合不同的小波函数生成的。# 这里可以定义 Framelet 基函数,例如一些小波基函数的线性组合# 这是一个示例函数,具体实现需要根据具体的 Framelet 设计# 示例:正弦函数。

qq_33009429的博客 1212

链表-1

21. 合并两个有序链表 struct ListNode* mergeTwoLists(struct ListNode* l1, struct ListNode* l2){ if(!l1) return l2; else if(!l2) return l1; struct ListNode *head=(struct ListNode*)malloc(sizeof(struct ListNode)); struct ListNode...

云淡风轻_的博客 483

msf后渗透之获取登入password、远程控制、调用摄像头

在terminal输入load kili creds_all直接获取密码(不一定成功) 使用kiwi_cmd sekurlsa::logonpasswords获取密码

m0_61506558的博客 2964

YOLO26涨点改进 | 全网独家复现、小目标检测改进篇 | TGRS 2025 | YOLO26引入MFAE-YOLO中的GFFP、FCPS 和 C3k2-FPEU创新点,涨点起飞,直接发论文

🔥本文给大家介绍在YOLO26中引入MFAE-YOLO中的 GFFP(全局特征融合处理)、FCPS(特征通道像素注意力) 和 C3k2-FPEU(特征池提取单元) 二次创新改进模块,能显著提升对小目标的检测性能。GFFP通过多尺度特征融合增强全局上下文感知能力,有效提升小目标在复杂背景下的可辨性;FCPS融合通道、像素和空间注意力机制,增强了模型对关键细节和小区域特征的关注,提升检测精度;C2F-FPEU利用多种池化方式挖掘细节特征,优化浅层特征表示能力。三者协同提升了YOLO26在小目标检测中的鲁棒性。

Ai缝合怪、助力小伙伴高效发论文 307

LeetCode 算法学习(7)

题目描述 Remove Nth Node From End of List Given a linked list, remove the n-th node from the end of list and return its head. Example: Given linked list: 1-&gt;2-&gt;3-&gt;4-&gt;5, and n = 2. After remo...

L_Realoo的博客 245

ARM交叉编译gdbserver并远程在线调试

arm-linux平台。5、生成完整的makefile,新建full_install,执行 ./configure --target=arm-linux-gnueabihf --host=arm-linux-gnueabihf --program-prefix=arm-linux-gnueabihf- CC=arm-linux-gnueabihf-gcc --prefix=/home/geyuxi/Documents/full_install。如果--host和--build不同,是交叉编译;

wangjie36的博客 3169

数据结构————单链表

单链表(Singly Linked List)是一种基本的数据结构,它由一系列节点组成,每个节点包含两部分:数据域和指针域。数据域用于存储实际的数据,而指针域则存储指向链表中下一个节点的地址。在单链表中,除了最后一个节点外,每个节点的指针域都指向下一个节点,最后一个节点的指针域通常设置为NULL,以标识链表的结束。单链表的特点是其存储不需要连续的内存空间,节点可以分散在内存中的任意位置,通过指针连接形成线性结构。头插法指的是在单链表的头部插入节点。新节点的指针将指向当前的头节点,然后更新头指针以指向新节点。

m0_66847953的博客 8659

汉书HE8,好用的汇编代码编写工具

汉书HE8,好用的汇编代码编写工具早期编写汇编代码所用功能强大

LinePhone3.2.7(android端最新版本) sip客户端

SIP客户端For android:LinePhone3.2.7(最新版本),官网地址:http://www.linphone.org/

数据结构——单链表

在链表中,没有增容(realloc)的概念,需要插入新的数据时,直接申请(malloc)一个结点大小的空间就可以了。

zoelinkailuo的博客 1123

STM32F407中文手册

STM32f407中文手册 本参考手册面向应用开发人员,提供有关使用 STM32F405xx/07xx、STM32F415xx/17xx、 STM32F42xxx 和 STM32F43xxx 微控制器存储器与外设的完整信息。STM32F405xx/07xx、STM32F415xx/17xx、STM32F42xxx 和 STM32F43xxx 构成一个微 控制器系列,各产品具有不同的存储器大小、封装和外设。有关订购信息以及器件的机械与电气特性,请参见数据手册。有关 ARM Cortex™-M4F 内核的信息,请参见《Cortex™-M4F 技术参考手册》。

【数据结构】单链表

数据结构中的单链表

m0_62531913的博客 1311

OV9734 DATASHEET,完整规格书

OV9734完整规格书,包括电气参数,尺寸规格,寄存器配置表等

C-数据结构之单链表逆置

11.25-学习笔记 单链表的逆置-大概思想就是新建立一个头结点,然后让之前的结点使用头插法插入到新建立的链表中。(这个也是使用快慢指针判断回文串中前半部分逆置的思想(我感觉是这样的)) //实现单链表的逆置 //逆置单链表就是新创建一个链表,然后让原始列表的每一个结点使用头插法插入到新链表中。 #include<stdio.h> #include<stdlib.h> typedef struct node{ int data; struct node * next; }Lno

nnluop的博客 7465

数据结构—单链表

主要介绍单链表的概念和对比顺序表的优缺点,还有单链表的接口实现代码的详细解释和源代码

2301_79601095的博客 2097

数据结构之模拟单链表

package com.qiangqiang; import java.util.LinkedList; /** * \* Created with IntelliJ IDEA. * \* @author: xiyue * \* Date: 2020/12/29 * \* Time: 15:19 * \* To change this template use File | Settings | File Templates. * \* Description: * \ */ publi

京北游戏官方 7692

【单链表】数据结构,详解单链表,java实现代码

单链表基本操作,详解单链表

程序员良辰 2659

数据结构 【单链表】

‌数据域用于存储实际的数据,而指针域则存储指向下一个节点的地址。单链表的特点包括动态存储、非连续存储、易于插入和删除。节点可以定义成一个结构体,每个节点中包含一个数据和下一个节点的地址。上面的结构体定义了一个节点,节点中存放的数据类型被定义成了SLDataType类型,节点的名称叫做SLNode。

qq_70199082的博客 2625

【数据结构】单链表2

尾插、尾删、头插、头删、查找、指定位置前插/删、指定位置后插/删、销毁。希望对大家有所帮助,一起加油,一起进步!

枫の大一分享 1398

数据结构之——单链表

深入了解单链表:数据结构中的灵活利器

m0_71974552的博客 1633

数据结构之单链表——考研笔记

单链表一个节点需要存放数据元素和指向下一个节点的指针,由于每个节点只包含一个指针,所以叫单链表。单链表:改变容量方便,但不可随机存取。

weixin_73236117的博客 887
上一篇: Linux字符驱动
下一篇: free()到底做了什么
Tobiu
博客等级 码龄10年 51粉丝 87原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值