五分钟搞懂“单链表“底层实现

已于 2022-08-24 15:19:06 修改
阅读量102 收藏
点赞数 1
分类专栏： 数据结构 文章标签： 链表 数据结构
于 2022-08-19 09:00:00 首次发布
DEXTER
本文链接：https://blog.csdn.net/DEXTERFUTIAN/article/details/126374828
版权

无头单向非循环链表

什么是链表？

链表是一种物理存储结构上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表
中的指针链接次序实现的 。
在这里插入图片描述

我们在日常生活种用的最多的就是以下两种：

在这里插入图片描述
在这里插入图片描述

链表简介

无头单向非循环链表：结构简单，一般不会单独用,是作为其他数据结构的子结构，如哈希桶、图的邻接表等等。另外这种结构在笔试面试种出现很多。
带头双向循环链表：结构最复杂，一般用在单独存储数据。实际中使用的链表数据结构，都是带头双向循环链表。另外这个结构虽然结构复杂，但是使用代码实现以后会发现结构会带来很多优势，实现反而简单了，后面我们代码实现了就知道了。

无头单向非循环链表实现

typedef int SLTDataType;
typedef struct SListNode
{
	SLTDataType data;
	struct SListNode* next;
}SCL;

我们在结构体里面不能直接将typedef重定义的结构体名，又重新在结构体里面用，比如下面这样就不可取：
typedef struct SListNode
{
SLTDataType data;
SCL next;
}SCL;

主要功能的接口：

// 动态申请一个节点
SCL* BuySListNode(SLTDataType x);
// 单链表打印
void SListPrint(SCL* phead);
// 单链表尾插
void SListPushBack(SCL** pphead, SLTDataType x);
// 单链表的头插
void SListPushFront(SCL** pphead, SLTDataType x);
// 单链表的尾删
void SListPopBack(SCL** pphead);
// 单链表头删
void SListPopFront(SCL** pphead);
// 单链表查找
SCL* SListFind(SCL* phead, SLTDataType x);
// 单链表在pos位置之后插入x
void SListInsertAfter(SCL* pos, SLTDataType x);
// 单链表删除pos位置之后的值
void SListEraseAfter(SCL* pos);
// 在pos之前插入
void SListInsert(SCL** pphead, SCL* pos, SLTDataType x);
// 删除pos位置
void SListErase(SCL** pphead, SCL* pos);

单链表增加与删除

// 动态申请一个节点
SCL* BuySListNode(SLTDataType x)
{
	SCL* newnode = (SCL*)malloc(sizeof(SCL));
	if (newnode == NULL)
	{
		perror("malloc fail");
		exit(-1);
	}
	newnode->data = x;
	newnode->next = NULL;

	return newnode;
}

头插头删

// 单链表的头插
void SListPushFront(SCL** pphead, SLTDataType x)
{
	assert(pphead);

	SCL* newnode = BuySListNode(x);
	//假如链表为空，也能正常运行
	newnode->next = *pphead;
	*pphead = newnode;
}
// 单链表的头删
void SListPopFront(SCL** pphead)
{
	assert(pphead);
	assert(*pphead != NULL);

	SCL* cur = *pphead;
	*pphead = (*pphead)->next;
	free(cur);
	cur = NULL;
}

尾插尾删

// 单链表的尾插
void SListPushBack(SCL** pphead, SLTDataType x)
{
	assert(pphead);
	SCL* newnode = BuySListNode(x);

	//1.空
	if (*pphead==NULL)
	{
		*pphead = newnode;
	}
	//2.非空
	else
	{
		//找单链表尾部
		SCL* Tail = *pphead;
		while (Tail->next!=NULL)
		{
			Tail = Tail->next;
		}
		Tail->next = newnode;
	}
}
// 单链表的尾删
void SListPopBack(SCL** pphead)
{
	assert(pphead);
	// 暴力检查
	assert(*pphead != NULL);
	// 1、一个节点
	if ((*pphead)->next == NULL)
	{
		free(*pphead);
		*pphead = NULL;
	}
	// 2、多个节点
	else
	{
		SCL* tail = *pphead;
		while (tail->next->next != NULL)
		{
			tail = tail->next;
		}
		free(tail->next);
		tail->next = NULL;
	}
}

单链表查找

// 单链表查找
SCL* SListFind(SCL* phead, SLTDataType x)
{
	SCL* cur = phead;
	while (cur)
	{
		if (cur->data == x)
		{
			return cur;
		}
		cur = cur->next;
	}
	return NULL;
}

单链表更改

POS位置之后插入X

// 单链表在pos位置之后插入x
void SListInsertAfter(SCL* pos, SLTDataType x)
{
	assert(pos);
	SCL* newnode = BuySListNode(x);
	newnode->next = pos->next;
	pos->next = newnode;
}

POS位置之前插入X

// 在pos之前插入
void SListInsert(SCL** pphead, SCL* pos, SLTDataType x)
{

	assert(pphead);
	assert(pos);
	if (pos == *pphead)
	{
		SListPushFront(pphead,x);
	}
	else
	{
		SCL* cur = *pphead;
		while (cur->next != pos)
		{
			cur = cur->next;
			//如果直到cur为空也没有与pos匹配，那么直接断言报错
			assert(cur);
		}
		SCL* newnode = BuySListNode(x);
		newnode->next = pos;
		cur->next = newnode;
	}
}

POS位置之后删除

// 单链表删除pos位置之后的值
void SListEraseAfter(SCL* pos)
{
	assert(pos);
	if (pos->next == NULL)
	{
		return;
	}
	else
	{
		SCL* next = pos->next;
		pos->next = next->next;
		free(next);
		next = NULL;
	}
}

删除POS位置的值

// 删除pos位置
void SListErase(SCL** pphead, SCL* pos)
{
	assert(pphead);
	assert(pos);
	if (pos == *pphead)
	{
		SListPopFront(pphead);
	}
	else
	{
		SCL* cur = *pphead;
		while (cur->next != pos)
		{
			cur = cur->next;
			//如果没找到，直接报错
			assert(cur);
		}
		cur->next = pos->next;
		free(pos);
		pos = NULL;
	}
}

头文件代码

#pragma once
#include<stdio.h>
#include<assert.h>
#include <stdlib.h>

// 1、无头+单向+非循环链表增删查改实现
typedef int SLTDataType;
typedef struct SListNode
{
	SLTDataType data;
	struct SListNode* next;
}SCL;

// 动态申请一个节点
SCL* BuySListNode(SLTDataType x);

// 单链表打印
void SListPrint(SCL* phead);

// 单链表尾插
void SListPushBack(SCL** pphead, SLTDataType x);

// 单链表的头插
void SListPushFront(SCL** pphead, SLTDataType x);

// 单链表的尾删
void SListPopBack(SCL** pphead);

// 单链表头删
void SListPopFront(SCL** pphead);

// 单链表查找
SCL* SListFind(SCL* phead, SLTDataType x);

// 单链表在pos位置之后插入x
void SListInsertAfter(SCL* pos, SLTDataType x);

// 单链表删除pos位置之后的值
void SListEraseAfter(SCL* pos);

// 在pos之前插入
void SListInsert(SCL** pphead, SCL* pos, SLTDataType x);

// 删除pos位置
void SListErase(SCL** pphead, SCL* pos);

函数实现代码

#include "SList.h"

// 动态申请一个节点
SCL* BuySListNode(SLTDataType x)
{
	SCL* newnode = (SCL*)malloc(sizeof(SCL));
	if (newnode == NULL)
	{
		perror("malloc fail");
		exit(-1);
	}
	newnode->data = x;
	newnode->next = NULL;

	return newnode;
}

// 单链表打印
void SListPrint(SCL* phead)
{
	SCL* cur = phead;	
	while (cur!=NULL)
	{
		printf("%d->", cur->data);
		cur = cur->next;
	}
	printf("NULL\n");
}

// 单链表尾插
void SListPushBack(SCL** pphead, SLTDataType x)
{
	assert(pphead);
	SCL* newnode = BuySListNode(x);

	//1.空
	if (*pphead==NULL)
	{
		*pphead = newnode;
	}
	//2.非空
	else
	{
		//找单链表尾部
		SCL* Tail = *pphead;
		while (Tail->next!=NULL)
		{
			Tail = Tail->next;
		}
		Tail->next = newnode;
	}
}

// 单链表的头插
void SListPushFront(SCL** pphead, SLTDataType x)
{
	assert(pphead);

	SCL* newnode = BuySListNode(x);
	//假如链表为空，也能正常运行
	newnode->next = *pphead;
	*pphead = newnode;
}

// 单链表的尾删
void SListPopBack(SCL** pphead)
{
	//第一种
	//assert(pphead);
	//assert(*pphead != NULL);
	//SCL* Tail = *pphead;
	//SCL* cur = *pphead;
	//if (cur->next == NULL)
	//{
	//	free(cur);
	//	cur = NULL;
	//}
	//while (cur->next->next != NULL)
	//{
	//	cur = cur->next;
	//}
	//Tail = cur->next;
	//cur->next = NULL;
	//free(Tail);
	//Tail = NULL;

	//第二种
	assert(pphead);
	// 温柔的检查
	if (*pphead == NULL)
	{
		return;
	}

	// 暴力检查
	//assert(*pphead != NULL);

	// 1、一个节点
	// 2、多个节点
	if ((*pphead)->next == NULL)
	{
		free(*pphead);
		*pphead = NULL;
	}
	else
	{
		SCL* tail = *pphead;
		while (tail->next->next != NULL)
		{
			tail = tail->next;
		}

		free(tail->next);
		tail->next = NULL;
	}
}

// 单链表头删
void SListPopFront(SCL** pphead)
{
	assert(pphead);
	assert(*pphead != NULL);

	SCL* cur = *pphead;
	*pphead = (*pphead)->next;
	free(cur);
	cur = NULL;
}

// 单链表查找
SCL* SListFind(SCL* phead, SLTDataType x)
{
	SCL* cur = phead;
	while (cur)
	{
		if (cur->data == x)
		{
			return cur;
		}
		cur = cur->next;
	}
	return NULL;
}

// 单链表在pos位置之后插入x
void SListInsertAfter(SCL* pos, SLTDataType x)
{
	assert(pos);
	SCL* newnode = BuySListNode(x);
	//第一种方法
	//SCL* cur = pos->next;
	//pos->next = newnode;
	//newnode->next = cur;
	//第二种方法
	newnode->next = pos->next;
	pos->next = newnode;
}

// 单链表删除pos位置之后的值
void SListEraseAfter(SCL* pos)
{
	assert(pos);
	if (pos->next == NULL)
	{
		return;
	}
	else
	{
		SCL* next = pos->next;
		pos->next = next->next;
		free(next);
		next = NULL;
	}
}

// 在pos之前插入
void SListInsert(SCL** pphead, SCL* pos, SLTDataType x)
{

	assert(pphead);
	assert(pos);
	if (pos == *pphead)
	{
		SListPushFront(pphead,x);
	}
	else
	{
		SCL* cur = *pphead;
		while (cur->next != pos)
		{
			cur = cur->next;
			//如果直到cur为空也没有与pos匹配，那么直接断言报错
			assert(cur);
		}
		SCL* newnode = BuySListNode(x);
		newnode->next = pos;
		cur->next = newnode;
	}
}

// 删除pos位置
void SListErase(SCL** pphead, SCL* pos)
{
	assert(pphead);
	assert(pos);
	if (pos == *pphead)
	{
		SListPopFront(pphead);
	}
	else
	{
		SCL* cur = *pphead;
		while (cur->next != pos)
		{
			cur = cur->next;
			//如果没找到，直接报错
			assert(cur);
		}
		cur->next = pos->next;
		free(pos);
		pos = NULL;
	}
}

如果发现错误欢迎大佬们指出😸😸

侠客cheems
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
单链表的详解以及C语言和JAVA的实现
Fat fat Wolf的博客
10-29 775
前文:最近发现基础好重要，学过的容易忘，刷letCode题时候，做到了跟数据结构相关的链表，树才发现，大学学的，都忘了，没办法，选择了代码这条路，就要重新找回来基础，大学不努力，毕业徒伤悲，出来混总是要还的。 最近在看到单链表时候，对指针创建，跟结构体对齐内存等遇到了好多新鲜的知识点，让我想起了abandon这个当初学的第一个词，但是wolf能回头吗?代码都搞不定，以后怎么娶媳妇，怀着这种信念的...
C语言单链表的实现
09-02
本文将深入探讨C语言中单链表的实现，并介绍相关的函数及其功能。 首先，我们需要定义链表节点的结构体。在`SList.h`中，我们看到如下定义： ```c typedef int DataType; typedef struct SListNode{ DataType ...
手写单向链表底层实现
08-12 133
package com.liuyuan.test03; public class SingleLinkedList { //这里不需要数组，不需要其他的复杂的结构，我只要记录单向链表的“头”结点 private Node first;//first中记录的是第一个结点的地址...
单向链表
【欢迎关注公众号：冬瓜白】
09-10 209
链表是一种非常重要的线性数据结构。动态数组、栈、队列底层仍然是依托的静态数组，通过“扩容”解决静态数组容量固定的问题，链表与它们不一样，链表是一种真正的动态数据结构，也是最简单的动态数据结构。链表与引用（指针）有关联。 链表（Linked List）数据是储存在一种叫节点（Node）的结构中： class Node{ //真正的数据 E e; //指向当前节点的下一个...
数据结构 | 单链表SingleList【带你从浅入深真正搞懂链表】
做技术人 · 产优质博客 · 找好工作
11-10 3781
万字详解单链表，带你从浅入深真正搞懂链表，不再为指针而苦恼
HashMap的底层结构和实现原理
热门推荐
C18298182575的博客
02-13 1万+
转自：https://www.cnblogs.com/chengxiao/p/6059914.html 　　哈希表（hash table）也叫散列表，是一种非常重要的数据结构，应用场景及其丰富，许多缓存技术（比如memcached）的核心其实就是在内存中维护一张大的哈希表，而HashMap的实现原理也常常出现在各类的面试题中，重要性可见一斑。本文会对java集合框架中的对应实现HashMap的实...
一篇文章搞懂二叉树
FZ51111的博客
05-29 1368
拿中序来说，拿到这棵树，第一个节点也就是根，但是不会访问他的值，因为中序访问就是先访问左子树，对于A这棵树而言，左子树是以B为根的子树，但是这时候不能访问B的值，因为对于B而言，D才是B的左子树，对于D而言，左子树为空，返回NULL（这也就是中序第一个NULL的来源）。什么意思呢，就是如果这个节点有子节点，也就是该节点的孩子，就让这个节点的左孩子指针保存孩子的地址，如果该节点没用孩子，就指向空，如果该节点的父节点除了该节点还有其他的子节点，就让该节点的右兄弟指向兄弟节点。比如，5个节点的树，一定有4条边。
看完豁然开朗！一起来聊聊Synchronized底层实现原理
CHAMPION8888的博客
06-17 176
前言 消息中间件作为分布式系统的重要成员，各大公司及开源均有许多解决方案。目前主流的开源解决方案包括RabbitMQ、RocketMQ、Kafka、ActiveMQ等。消息这个东西说简单也简单，说难也难。简单之处在于好用方便，接入简单使用简单，异步操作能够解耦系统间的依赖，同时失败后也能够追溯重试。难的地方在于，设计一套可以支撑业务的消息机制，并提供高可用架构，解决消息存储、消息重试、消息队列的负载均衡等一系列问题。然而难也不代表没有方法或者“套路”，熟悉一下原理与实现，多看几个框架的源码后多总结势必能找
一篇博客搞懂HashMap相关知识
m0_61820867的博客
09-08 1012
详细介绍了HashMap，包括jdk不同版本的升级以及底层的源码分析
五分钟搞懂Android的消息机制(Handle,Looper,MessageQueue)
cuishikun9527的博客
06-01 1004
引言： 提到消息机制相比各位都应该不是很陌生，日常开发的过长中肯定难免遇到这方面的问题。Handle的运行需要底层的Looper,MessageQueue进行支撑。MessageQueue的中文翻译是消息队列，说白了，他的内部储存了信息，以队列的形式来提供插入和删除的工作。虽说是队列，但是其内部的实现确实单链表。而MessageQueue只提供了对于消息的存储功能，但是如果要对消息进行遍历和处理的
单链表的实现-简单操作
11-18
单链表的实现-简单操作
C语言实现单链表实现方法
08-29
本篇文章将深入探讨如何使用C语言实现单链表。 首先，单链表是由一系列节点构成，每个节点包含数据部分和指向下一个节点的指针。单链表分为两种形式：带头节点和不带头节点。带头节点的链表有一个额外的节点作为...
单链表的实现
04-21
单链表是一种基础的数据结构，它在计算机科学中扮演着重要的角色。单链表由一系列节点组成，每个节点包含两部分：数据元素和一个指向下一个节点的指针。这种数据结构允许快速的插入和删除操作，但随机访问的效率较低...
PHP单链表的实现代码
12-18
了解了这些基本操作后，开发者可以基于单链表实现更复杂的数据结构和算法，例如栈、队列或图。单链表的灵活性使其在处理动态数据集合时非常有用，因为插入和删除操作通常比数组更快，特别是在需要频繁调整大小的情况...
从零开始学数据结构系列之第四章《prim算法（普里姆算法）详解》
铁匠匠匠的博客
07-18 1063
可以参考以下视频。
数据结构day3
最新发布
qq_55245263的博客
07-18 283
顺序表实现学生管理系统
(C++二叉树02) 翻转二叉树 对称二叉树 二叉树的深度
qq_44962949的博客
07-17 245
【代码】(C++二叉树02) 翻转二叉树 对称二叉树 二叉树的深度。
数据结构初阶·排序算法(内排序)
2301_79697943的博客
07-18 917
目前常见的排序算法有9种，冒泡排序，选择排序，插入排序，希尔排序，快速排序，归并排序，计数排序，基数排序，桶排序。实际生活中排序的应用也是有限的，今天我们介绍其中7个，基数排序和桶排序不介绍。介绍常用的即可。顺带一嘴，本文里面所有的排序都是内排序，也就是在内存里面进行排序的，还有一种排序叫做外排序，即是在磁盘里面进行排序的，这种排序具有记忆性，外排序用到的就是归并排序，因为归并排序有一个特点就是空间复杂度为O(N)。好了正文开始。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

侠客cheems

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

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

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

打赏作者

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

抵扣说明：

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

余额充值