[数据结构]——单链表超详细总结

news2024/10/7 10:25:27

带你走进链表的世界

  • 目录：
  • 一、线性表的概念
  • 二、顺序表
  • 三、链表
    • 3.1 链表的概念
    • 3.2 链表的分类
    • 3.3 无头+单向+非循环链表的实现
    • 3.4 带头+双向+循环链表的实现
  • 四、顺序表和链表的区别和联系

目录：

链表是个优秀的结构，没有容量概念，可以在任意位置增加删除数据，这个博客，我准备花大量篇幅去总结链表（特别是单链表），同时也总结一下顺序表（顺序表和我们以前写的通讯录动态版类似，一般采用数组存储的方法，在数组上完成数据的增删查改）

一、线性表的概念

线性表的定义：由n个数据元素组成具有相同特性的有限序列。
常见的线性表：顺序表、链表、栈、队列、字符串等等。
线性表的概念：线性表在逻辑上是线性结构，也就是说它是一条直线，它的物理结构并不一定是连续的，线性表在物理上存储时，通常以数组和链表的形式存储。

二、顺序表

顺序表的定义：
顺序表是一段物理地址连续的存储单元，是一种用来依次存储数据的线性结构。
在这里插入图片描述
1.静态顺序表：使用定常数组存储元素

#define N 7//方便改变数组大小
typedef int SLDatatype;
typedef struct SLD
{
SLDatatype arr[N];//定长数组
size_t size;//有效数据的个数
}SeqList;//顺序表

2.动态顺序表：使用动态开辟的数组存储元素（空间不够就可以扩容）

typedef int SLDatatype;
typedef struct SLD
{
SLDatatype* p;//指向动态开辟的数组
size_t size;//有效数据的个数
size_t capicity;//表示容量空间的大小
}SeqList;//顺序表

三、链表

3.1 链表的概念

链表是一种物理存储结构上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。
注意:
链式结构在逻辑上是连续的，但是在物理上不一定连续。
现实中的节点一般都是从堆上申请出来的
从堆上申请的空间是按照一定的策略来分配的，两次申请的空间可能连续，也可能不连续。

3.2 链表的分类

链表的结构非常多，结合起来有8种：
1、单向或者双向
在这里插入图片描述
2、带头或者不带头
在这里插入图片描述
3、循环或者不循环
在这里插入图片描述
实际中常用的两种结构是：

  1. 无头单向非循环链表 ：
    结构简单，一般不会单独存数据。其他数据的子结构，如哈希桶、图的领接表等等。
  2. 带头双向循环链表：
    结构最复杂，一般可以单独存数据。实际中使用的链表数据结构，都是带头双向循环链表。

3.3 无头+单向+非循环链表的实现

头文件里的函数声明

// slist.h
typedef int SLTDateType;
typedef struct SListNode
{
	SLTDateType data;
	struct SListNode* next;
}SListNode;

// 动态申请一个节点
SListNode* BuySListNode(SLTDateType x);
// 单链表打印
void SListPrint(SListNode* plist);
// 单链表尾插
void SListPushBack(SListNode** pplist, SLTDateType x);
// 单链表的头插
void SListPushFront(SListNode** pplist, SLTDateType x);
// 单链表的尾删
void SListPopBack(SListNode** pplist);
// 单链表头删
void SListPopFront(SListNode** pplist);
// 单链表查找
SListNode* SListFind(SListNode* plist, SLTDateType x);
// 单链表在pos位置之后插入x
void SListInsertAfter(SListNode* pos, SLTDateType x);
// 单链表删除pos位置之后的值
void SListEraseAfter(SListNode* pos);
// 单链表的销毁
void SListDestroy(SListNode** pplist);

下面将是各个函数的实现

// slist.c
#include "SList.h"
//动态申请一个结点
SListNode* BuySListNode(SLTDateType x)
{
//在堆上开辟一个存放指针的变量，并给它初始化
	SListNode* node = (SListNode*)malloc(sizeof(SListNode));
	node->data = x;
	node->next = NULL;
	return node;//返回指针
}
//单链表打印
void SListPrint(SListNode* plist)
{
//定义一个指针，指针指向头指针
	SListNode* cur = plist;
	//遍历指针，不是空就循环
	while (cur)
	{
		printf("%d->", cur->data);
		cur = cur->next;
	}
	//cur指向空
	printf("NULL\n");
}
//单链表尾插一个数据
void SListPushBack(SListNode** pplist, SLTDateType x)
{
//开辟一个新结点
	SListNode* newnode = BuySListNode(x);
	//如果头指针指向的是空就让它指向这个新结点
	if (*pplist == NULL)
	{
		*pplist = newnode;
	}
	else//如果头指针指向的不是空
	{
	//创建一个尾指针
		SListNode* tail = *pplist;
		//尾指针不在尾部，遍历单链表，让尾指针指向链表的最后结点
		while (tail->next != NULL)
		{
			tail = tail->next;
		}
//把开辟的新结点尾插到尾指针结点的下一个结点
		tail->next = newnode;
	}
}
//单链表尾删
void SListPopBack(SListNode** pplist)
{
//定义两个指针
	SListNode* prev = NULL;//当前位置的指针
	SListNode* tail = *pplist;//尾结点的指针
	// 1.空、只有一个节点
	// 2.两个及以上的节点
	if (tail == NULL || tail->next == NULL)
	{
//给空间释放
		free(tail);
		*pplist = NULL;
	}
	else
	{
	//遍历链表，找到尾指针
		while (tail->next)
		{
			prev = tail;
			tail = tail->next;
		}

		free(tail);
		tail = NULL;
//让最后一个结点指向空
		prev->next = NULL;
	}
}

//单链表头插法
void SListPushFront(SListNode** pplist, SLTDateType x)
{
//这个指针是空就报错
	assert(pplist);
	// 1.空
	// 2.非空
	SListNode* newnode = BuySListNode(x);
	if (*pplist == NULL)//pplist指针指向的是空
	{
		*pplist = newnode;
	}
	else
	{
	//在*pplist指针指向的那个结点前面头插一个结点
		newnode->next = *pplist;
		//*pplist指针重新指向头结点
		*pplist = newnode;
	}
}
//单链表头删
void SListPopFront(SListNode** pplist)
{
	// 1.空
	// 2.一个
	// 3.两个及以上
	SListNode* first = *pplist;//定义一个头指针，它为空就返回，
	if (first == NULL)
	{
		return;
	}
	else if (first->next == NULL)//只有一个结点，就释放空间，然后置空
	{
		free(first);
		*pplist = NULL;
	}
	else
	{
	//两个以上结点
		SListNode* next = first->next;//把头指针的下一个结点位置存起来
		free(first);//释放头指针
		*pplist = next;//让首指针重新指向头指针
	}
}
 单链表查找
SListNode* SListFind(SListNode* plist, SLTDateType x)
{
	SListNode* cur = plist;
	while (cur)
	{
		if (cur->data == x)
			return cur;

		cur = cur->next;
	}

	return NULL;
}
// 单链表在pos位置之后插入x
void SListInsertAfter(SListNode* pos, SLTDateType x)//用单链表查找，找到值x的位置，返回的指针给pos
{
	assert(pos);
	SListNode* next = pos->next;//next指针存放pos之后的节点
	SListNode* newnode = BuySListNode(x);//开辟一个新结点
	pos->next = newnode;//在pos后面插入新开辟的结点
	newnode->next = next;//让新结点连接上next指向的那个结点
}
// 单链表删除pos位置之后的值
void SListEraseAfter(SListNode* pos)//用单链表查找，找到值x的位置，返回的指针给pos
{
	assert(pos);
	// pos next nextnext
	SListNode* next = pos->next;

	if (next != NULL)
	{
		SListNode* nextnext = next->next;
		free(next);
		pos->next = nextnext;
	}
}
// 单链表的销毁
void SListDestroy(SListNode** pplist)
{
    
    SListNode* cur = *pplist;
    while (cur)
    {
        *pplist = cur->next;
        free(cur);
        cur = *pplist;
    }
}

3.4 带头+双向+循环链表的实现

头文件里的函数声明

#define _CRT_SECURE_NO_WARNINGS 1
#pragma once
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
// 带头+双向+循环链表增删查改实现
typedef int LTDataType;
typedef struct ListNode
{
	LTDataType data;
	struct ListNode* next;
	struct ListNode* prev;
}ListNode;
//创建新结点
 ListNode* ListNodes(LTDataType x);
//双向链表初始化
 ListNode* ListInit();
// 双向链表销毁
void ListDestory(ListNode* pHead);
// 双向链表打印
void ListPrint(ListNode* phead);
// 双向链表尾插
void ListPushBack(ListNode* phead, LTDataType x);
// 双向链表尾删
void ListPopBack(ListNode* phead);
// 双向链表头插
void ListPushFront(ListNode* phead, LTDataType x);
// 双向链表头删
void ListPopFront(ListNode* phead);
//求链表有多少数据
int listsize(ListNode* phead);
// 双向链表查找
ListNode* ListFind(ListNode* phead, LTDataType x);
// 双向链表在pos的前面进行插入
void ListInsert(ListNode* pos, LTDataType x);
// 双向链表删除pos位置的节点
void ListErase(ListNode* pos);

函数的定义实现

// 创建新节点
ListNode* ListNodes(LTDataType x)
{
    ListNode* head = (ListNode*)malloc(sizeof(ListNode));
    if (head == NULL)
    {
        perror("malloc fail");
        exit(-1);
    }
    head->data = x;
    head->next = NULL;
    head->prev = NULL;
    return head;
}
//链表初始化
ListNode* ListInit()
{
    ListNode* phead = ListNodes(-1);
    phead->next = phead;
    phead->prev = phead;
    return phead;
}
// 双向链表尾插
void ListPushBack(ListNode* phead, LTDataType x)
{
    assert(phead);
    ListNode* newnode = ListNodes(x);//创建一个新节点
    ListNode* tail = phead->prev;
    newnode->data = x;
    //双向链表尾插
    tail->next = newnode;
    newnode->next = phead;
    newnode->prev = tail;
    phead->prev = newnode;
}
// 双向链表尾删
void ListPopBack(ListNode* phead)
{
    assert(phead);
    assert(phead->next != NULL);
    ListNode* tail = phead->prev;
    ListNode* tailPrev = tail->prev;
    free(tail);
    tailPrev->next = phead;
    phead->prev = tailPrev;
}
// 双向链表头插
void ListPushFront(ListNode* phead, LTDataType x)
{
    ListNode* next = phead->next;
    ListNode* newnode = ListNodes(x);
    phead->next = newnode;
    newnode->prev = phead;
    newnode->next = next;
    next->prev = newnode;
}
// 双向链表头删
void ListPopFront(ListNode* phead)
{
    assert(phead);
    assert(phead->next != NULL);
    ListNode* node = phead->next;
    phead->next = node->next;
    node->next->prev = phead;
    free(node);
}
//求链表有多少数据
int listsize(ListNode* phead)
{
    int  size = 0;
    assert(phead);
    ListNode* cur = phead->next;
    while (cur != phead)
    {
        size++;
        cur = cur->next;
    }
    return size;
}
// 双向链表查找
ListNode* ListFind(ListNode* phead, LTDataType x)
{
    ListNode* cur = phead->next;
    while (cur != phead)
    {
        if (cur->data == x)
            return cur;
        cur = cur->next;
    }
    return NULL;
}
// 双向链表在pos的前面进行插入
void ListInsert(ListNode* pos, LTDataType x)
{
    ListNode* newnode = ListNodes(x);
    ListNode* prevnode = pos->prev;
    prevnode->next = newnode;
    newnode->prev = prevnode;
    newnode->next = pos;
    pos->prev = newnode;
}
// 双向链表删除pos位置的节点
void ListErase(ListNode* pos)
{
    assert(pos);
    ListNode* nodeprev = pos->prev;
    ListNode* nodenext = pos->next;
    free(pos);
    nodeprev->next = nodenext;
    nodenext->prev = nodeprev;
}
// 双向链表打印
void ListPrint(ListNode* phead)
{
    assert(phead);
    ListNode* cur = phead->next;
    while (cur != phead)
    {
        printf("%d<=>", cur->data);
        cur = cur->next;
    }
}
// 双向链表销毁
void ListDestory(ListNode* phead)
{
    //断言指针指针不为NULL
    assert(phead);
    ListNode* cur = phead;//定义一个指针
    //断开循环链表
    phead->prev->next = NULL;

    while (cur)
    {
        ListNode* Next = cur->next;
        free(cur);
        cur = Next;
    }
}

四、顺序表和链表的区别和联系

在这里插入图片描述
补充： 高速缓存利用率
先要对存储器的层次结构有一定了解
如图：
在这里插入图片描述
数据是存在内存中的，CPU要访问数据，它不会去内存直接访问数据。看数据在不在缓存，在缓存，数据就命中（cpu访问数据时，数据恰好在缓存里），不在缓存，访问不命中（cpu访问数据，不会把4个字节加载到缓存，它会把一长段的数据加载到缓存）

注意：CPU访问数据第一次不命中，第二次一定命中

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1089581.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

Python接口测试 requests.post方法中data与json参数区别

Python接口测试 requests.post方法中data与json参数区别

引言 requests.post主要参数是data与json&#xff0c;这两者使用是有区别的&#xff0c;下面我详情的介绍一下使用方法。 Requests参数 1. 先可以看一下requests的源码&#xff1a; 1 2 3 4 5 6 7 8 9 10 11 12 13 def post(url, dataNone, jsonNone, **kwargs): r&quo…
阅读更多...
STM32CUBEMX_DMA串口空闲中断接收+接收发送缓冲区

STM32CUBEMX_DMA串口空闲中断接收+接收发送缓冲区

STM32CUBEMX_DMA串口空闲中断接收接收发送缓冲区 前言&#xff1a; 我了解的串口接收指令的方式有&#xff1a;在这里插入图片描述 1、接收数据中断特定帧尾 2、接收数据中断空闲中断 3、DMA接收空闲中断 我最推荐第三种&#xff0c;尤其是数据量比较大且频繁的时候 串口配置 …
阅读更多...
Vmware Linux虚拟机安装教程（Centos版）

Vmware Linux虚拟机安装教程（Centos版）

文章目录 1.Vmware-workstation安装软件2.双击下载的安装包开始安装3.打开VMware-workstation&#xff0c;输入密钥4.Centos7.6安装软件5.新建虚拟机6.为虚拟机配置映像文件7.开启虚拟机&#xff0c;配置环境7.1 Install Centos 77.2 选择简体中文字体7.3 软件选择7.4 安装位置…
阅读更多...
LeetCode【20】 有效的括号

LeetCode【20】 有效的括号

题型&#xff1a;栈 题目&#xff1a; 代码&#xff1a; public boolean isValidReview(String s) {//&#xff08;1&#xff09;从s的i0位置一次开始压栈&#xff0c;遇到左括号压栈&#xff0c;不管是大中小三种&#xff0c;左括号&#xff0c;压//&#xff08;2&#xf…
阅读更多...
基于 EventBridge 轻松搭建消息集成应用

基于 EventBridge 轻松搭建消息集成应用

作者&#xff1a;昶风 前言 本篇文章主要介绍基于阿里云 EventBridge 的消息集成能力&#xff0c;结合目前消息产品的需求热点&#xff0c;从能力范围到场景实战&#xff0c;对 EventBridge 的消息集成解决方案进行了概要的介绍。 从消息现状谈起 消息队列作为应用解耦&…
阅读更多...
Redis 基础—Redis Desktop Manager(Redis可视化工具)安装及使用教程

Redis 基础—Redis Desktop Manager(Redis可视化工具)安装及使用教程

Redis Desktop Manager 是一个可视化的 Redis 数据库管理工具&#xff0c;可以方便地查看和操作 Redis 数据库。使用 Redis Desktop Manager 可以大大提高 Redis 数据库的管理效率。 RDM的安装和配置 首先&#xff0c;您需要下载和安装Redis Desktop Manager。 安装完成后&am…
阅读更多...
高校教务系统密码加密逻辑及JS逆向——皖南医学院

高校教务系统密码加密逻辑及JS逆向——皖南医学院

高校教务系统密码加密逻辑及JS逆向 本文将介绍高校教务系统的密码加密逻辑以及使用JavaScript进行逆向分析的过程。通过本文&#xff0c;你将了解到密码加密的基本概念、常用加密算法以及如何通过逆向分析来破解密码。 本文仅供交流学习&#xff0c;勿用于非法用途。 一、密码加…
阅读更多...
提升企业服务行业管理效率的关键策略与方法」

提升企业服务行业管理效率的关键策略与方法」

To B 服务&#xff0c;也即企业服务近年来大家关注的重点&#xff0c;企业服务是指为企业客户提供运营管理相关的工具与系统解决方案等服务&#xff0c;通过专业化的服务可以实现降本增效&#xff0c;提高企业的经营效率。 近年来&#xff0c;人口红利的消失促使企业服务需求快…
阅读更多...
DC电源模块低温是否影响转换效率

DC电源模块低温是否影响转换效率

BOSHIDA DC电源模块低温是否影响转换效率 DC电源模块是一种常用的电源转换装置&#xff0c;其主要作用是将输入的电源信号变换成需要的输出电源信号。在实际应用中&#xff0c;DC电源模块的性能会受到多种因素的影响&#xff0c;其中低温也是一个重要的影响因素。本文将从转换…
阅读更多...
kettle应用-从数据库抽取数据到excel

kettle应用-从数据库抽取数据到excel

本文介绍使用kettle从postgresql数据库中抽取数据到excel中。 首先&#xff0c;启动kettle 如果kettle部署在windows系统&#xff0c;双击运行spoon.bat或者在命令行运行spoon.bat 如果kettle部署在linux系统&#xff0c;需要执行如下命令启动 chmod x spoon.sh nohup ./sp…
阅读更多...
c++设计模式之单例设计模式

c++设计模式之单例设计模式

&#x1f482; 个人主页:[pp不会算法v](https://blog.csdn.net/weixin_73548574?spm1011.2415.3001.5343) &#x1f91f; 版权: 本文由【pp不会算法^v^】原创、在CSDN首发、需要转载请联系博主 &#x1f4ac; 如果文章对你有帮助、欢迎关注、点赞、收藏(一键三连)和订阅专栏哦…
阅读更多...
以命令行形式执行Postman脚本（使用Newman）

以命令行形式执行Postman脚本（使用Newman）

目录 一、背景 二、Newman的安装 三、脚本准备 四、Newman的执行 五、生成报告 一、背景 ​ Postman的操作离不开客户端。但是在一些情况下可能无法使用客户端去进行脚本执行。比如在服务端进行接口测试。由此我们引入了Newman。Newman基于Node.js开发&#xff0c;它使您可…
阅读更多...
【MySQL】表的查询与连接

【MySQL】表的查询与连接

文章目录 预备工作一、表的基本查询1、简单基本查询2、分组聚合统计3、基本查询练习 二、表的复合查询1、多表查询2、子查询2.1 **单行子查询**2.2 **多行子查询**2.3 **多列子查询**2.4 在from子句中使用子查询 3、合并查询 三、表的连接1、自连接2、内连接3、外连接 预备工作…
阅读更多...
【C++】关键字 命名空间 输入输出 缺省函数

【C++】关键字 命名空间 输入输出 缺省函数

一&#xff0c;C关键字 C 总计 63 个关键字&#xff0c;C语言 32 个关键字 直接上图&#xff1a; asmdoifreturntrycontinueautodoubleinlineshorttypedefforbooldynamic_castintsignedtypeidpublicbreakelselongsizeoftypenamethrowcaseenummutablestaticunionwchar_tcatche…
阅读更多...
Win11更新后瘦身C盘的两个小技巧

Win11更新后瘦身C盘的两个小技巧

每当windows更新完后&#xff0c;就很容易出现一个现象&#xff0c;那便是C盘存储变红了。 这个时候&#xff0c;就会有方法指出&#xff1a;把C盘中的系统更新文件清理掉吧&#xff0c;这样C盘就又能瘦回去了&#xff01; 然而&#xff0c;当你兴冲冲地按照网上的教程点击C…
阅读更多...
OPTEE之KASAN地址消毒动态代码分析

OPTEE之KASAN地址消毒动态代码分析

安全之安全(security)博客目录导读 目录 一、KASAN简介 二、OPTEE_OS中KASAN配置选项 三、OPTEE_OS中KASAN配置选项打开 一、KASAN简介 内核地址消毒器(KASAN)是Linux内核的快速内存损坏检测器&#xff0c;KASAN检测slab、page_alloc、vmalloc、stack和全局内存中的越界、u…
阅读更多...
Yarn基础入门

Yarn基础入门

文章目录 一、Yarn资源调度器1、架构2、Yarn工作机制3、HDFS、YARN、MR关系4、作业提交之HDFS&MapReduce 二、Yarn调度器和调度算法1、先进先出调度器&#xff08;FIFO&#xff09;2、容量调度器&#xff08;Capacity Scheduler&#xff09;3、公平调度器&#xff08;Fair …
阅读更多...
信钰证券：首板第二天买入技巧？

信钰证券：首板第二天买入技巧？

股票上市第一天&#xff0c;也就是所谓的“首板”&#xff0c;一般会引起商场的高度注重。那么关于投资者而言&#xff0c;如安在接下来的第二天进行买入是个十分要害的决议计划。本文将从多个角度剖析首板第二天买入技巧&#xff0c;供读者参阅。 首先&#xff0c;多数人或许…
阅读更多...
京东数据平台：2023年服饰行业销售数据分析

京东数据平台：2023年服饰行业销售数据分析

最近看到有些消费机构分析&#xff0c;不少知名的运动品牌都把“主战场”放到了冲锋衣&#xff0c;那么羽绒服市场就比较危险了。但其实羽绒服市场也有机会点可寻。 先来说冲锋衣。的确&#xff0c;从今年的销售数据以及增长情况&#xff0c;冲锋衣的确会是今年冬天的大热门品…
阅读更多...
领跑新周期！高通8295/8255上车，这家厂商已经整装待发

领跑新周期！高通8295/8255上车，这家厂商已经整装待发

围绕高通下一代8295/8255平台&#xff0c;一场激烈的市场争夺战已经打响。 目前&#xff0c;各大域控制器厂商、汽车软件厂商围绕高通8295/8255平台&#xff0c;已经推出了诸多的解决方案&#xff0c;以抢占下一代高性能SoC带来的全新市场红利。《高工智能汽车》了解到&#x…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023