数据结构之单链表

最新推荐文章于 2024-08-16 10:42:04 发布
最新推荐文章于 2024-08-16 10:42:04 发布
阅读量222 收藏 1
点赞数 1
分类专栏： 数据结构 文章标签： 链表 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_56663697/article/details/119567370
版权

文章目录

前言

顺序表中虽然代码简洁但是存在许多问题

  1. 中间/头部的插入删除，时间复杂度较高（O(N)）
  2. 增容时需要申请新空间，拷贝数据，释放旧空间。会有不小的消耗。
  3. 增容一般是呈2倍的增长，势必会有一定的空间浪费。例如当前容量为100，满了以后增容到200，我们再继续插入了5个数据，后面没有数据插入了，那么就浪费了95个数据空间。

如何解决上述问题呢？这里我们引入链表

链表的概念及结构

概念：链表是一种物理存储结构上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。

如下图
在这里插入图片描述
注意：

  1. 从上图可看出，链式结构在逻辑上是连续的，但是在物理上不一定连续
  2. 现实中的结点一般都是从堆上申请出来的
  3. 从堆上申请的空间，是按照一定的策略来分配的，两次申请的空间可能连续，也可能不连续

顺序表的功能实现

先创建三个文件SList.h（头文件），SList.c（函数文件），test.c（测试文件）
在这里插入图片描述

创建结点

typedef int SLTDataType;

typedef struct SListNode
{
	SLTDataType data;			//存放该结点的数据
	struct SListNode* next;		//存放下一结点的地址
}SLTNode;

单链表打印

将所有结点的数据按顺序打印出来

void SListPrint(SLTNode* phead)
{
	SLTNode* cur = phead;
	while (cur != NULL)
	{
		printf("%d->", cur->data);
		cur = cur->next;
	}
	printf("NULL\n");
}

单链表尾插

思路

  1. 遍历找到尾结点
  2. 创建新的结点
  3. 将新的结点连接到尾结点上
SLTNode* BuySListNode(SLTDataType x)
{
	//开辟新结点
	SLTNode* node = (SLTNode*)malloc(sizeof(SLTNode));
	if (node == NULL)
	{
		printf("malloc fail\n");
		exit(-1);
	}
	//对新结点进行初始化
	node->data = x;
	node->next = NULL;

	return node;
}

void SListPushBack(SLTNode** pphead, SLTDataType x)
{
	assert(pphead);
	if (*pphead == NULL)
	{
		SLTNode* newnode = BuySListNode(x);
		*pphead = newnode;
	}
	else
	{
		SLTNode* tail = *pphead;
		//找尾结点
		while (tail->next != NULL)
		{
			tail = tail->next;
		}
		SLTNode* newnode = BuySListNode(x);
		//连接
		tail->next = newnode;
	}
}

注意：这里可能会对首位结点进行修改需要传二级指针，如果传一级指针，在函数中修改首位结点无法返回给主程序（类似传址和传值问题）

检测
在这里插入图片描述

单链表头插

思路

  1. 创建一个新结点
  2. 将新结点插入链表头部
void SListPushFront(SLTNode** pphead, SLTDataType x)
{
	assert(pphead);
	//创建一个新结点
	SLTNode* newnode = BuySListNode(x);
	//头插
	newnode->next = *pphead;
	*pphead = newnode;
}

检测
在这里插入图片描述

单链表尾删

思路很简单找到尾结点释放就行了

void SListPopBack(SLTNode** pphead)
{
	assert(pphead);
	assert(*pphead);
	//单个结点
	if ((*pphead)->next == NULL)//->优先级比*高需要(*pphead)
	{
		free(*pphead);
		*pphead = NULL;
	}
	//多个结点
	else
	{
		SLTNode* prev = NULL;
		SLTNode* tail = *pphead;
		//找尾结点
		while (tail->next != NULL)
		{
			prev = tail;
			tail = tail->next;
		}
		//释放
		free(tail);
		prev->next = NULL;
	}
}

检测
在这里插入图片描述

单链表头删

将头结点删除释放，并把第二个结点置为头结点

void SListPopFront(SLTNode** pphead)
{
	assert(pphead);
	assert(*pphead);
	SLTNode* next = (*pphead)->next;
	free(*pphead);
	(*pphead) = next;
}

检测
在这里插入图片描述

计算链表大小

遍历，计算结点个数

int SListSize(SLTNode* phead)
{
	int size = 0;
	SLTNode* cur = phead;
	while (cur)
	{
		size++;
		cur = cur->next;
	}
	return size;
}

检测
在这里插入图片描述

判断链表是否为空

这里需要引入一个新类型bool，如果该函数为真返回1，为假返回0，需要引入头文件<stdbool.h>

bool SListEmpty(SLTNode* phead)
{
	return phead == NULL;
}

查找某个值

思路

  1. 遍历链表
  2. 将结点的值和要找的值进行比较，相同返回该结点的坐标
  3. 如果没找到返回空指针
SLTNode* SListFind(SLTNode* phead, SLTDataType x)
{
	SLTNode* cur = phead;
	while (cur)
	{
		if (cur->data == x)
		{
			return cur;
		}
		else
		{
			cur = cur->next;
		}
	}
	return NULL;
}

在指定位置插入

思路

  1. 找到目标结点的前一个结点
  2. 新建一个结点保存数据
  3. 将新结点连如链表中

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

void SListInsert(SLTNode** pphead, SLTNode* pos, SLTDataType x)
{
	assert(pphead);
	assert(pos);
	//如果在第一个结点前插入就首插
	if (*pphead == pos)
	{
		SListPushFront(pphead, x);
	}
	else
	{
		//找到pos前一个结点
		SLTNode* prev = *pphead;
		while (prev->next != pos)
		{
			prev = prev->next;
		}
		SLTNode* newnode = BuySListNode(x);
		newnode->next = pos;
		prev->next = newnode;
	}
}

检测
在这里插入图片描述

指定位置删除

思路

  1. 找到目标结点的前一个结点，和后一个结点
  2. 将目标结点的前后结点相连
  3. 删除目标结点

在这里插入图片描述

void SListErase(SLTNode** pphead, SLTNode* pos)
{
	assert(pphead);
	assert(pos);
	//一个结点时相当于头删
	if (*pphead == pos)
	{
		SListPopFront(pphead);
	}
	else
	{
		SLTNode* prev = *pphead;
		while (prev->next != pos)
		{
			prev = prev->next;
		}
		prev->next = pos->next;
		free(pos);
		pos = NULL;
	}
}

检测
在这里插入图片描述

单链表的销毁

将单链表依次销毁

void SListDestory(SLTNode** plist)
{
	assert(plist);
	SLTNode* cur = *plist;
	//将单链表依次销毁
	while (cur)
	{
		SLTNode* next = cur->next;
		free(cur);
		cur = next;
	}
	*plist = NULL;
}

检测
在这里插入图片描述

总结

SList.h

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

typedef int SLTDataType;

typedef struct SListNode
{
	SLTDataType data;
	struct SListNode* next;
}SLTNode;

void SListPrint(SLTNode* phead);
//尾插
void SListPushBack(SLTNode** pphead, SLTDataType x);
//头插
void SListPushFront(SLTNode** pphead, SLTDataType x);
//尾删
void SListPopBack(SLTNode** pphead);
//头删
void SListPopFront(SLTNode** pphead);
//计算链表大小
int SListSize(SLTNode* phead);
//判断链表是否为空
bool SListEmpty(SLTNode* phead);
//查找
SLTNode* SListFind(SLTNode* phead, SLTDataType x);
//pos位置前插
void SListInsert(SLTNode** pphead, SLTNode* pos, SLTDataType x);
// 在pos位置后面去插入x
void SListInsertAfter(SLTNode* pos, SLTDataType x);
// 删除pos位置的值
void SListErase(SLTNode** pphead, SLTNode* pos);
//删除pos后的值
void SListEraseAfter(SLTNode* pos);
// 单链表的销毁
void SListDestory(SLTNode** plist);

SList.c

#include"SList.h"
void SListPrint(SLTNode* phead)
{
	SLTNode* cur = phead;
	while (cur != NULL)
	{
		printf("%d->", cur->data);
		cur = cur->next;
	}
	printf("NULL\n");
}

SLTNode* BuySListNode(SLTDataType x)
{
	//开辟新结点
	SLTNode* node = (SLTNode*)malloc(sizeof(SLTNode));
	if (node == NULL)
	{
		printf("malloc fail\n");
		exit(-1);
	}
	//对新结点进行初始化
	node->data = x;
	node->next = NULL;

	return node;
}

void SListPushBack(SLTNode** pphead, SLTDataType x)
{
	assert(pphead);
	if (*pphead == NULL)
	{
		SLTNode* newnode = BuySListNode(x);
		*pphead = newnode;
	}
	else
	{
		SLTNode* tail = *pphead;
		//找尾结点
		while (tail->next != NULL)
		{
			tail = tail->next;
		}
		SLTNode* newnode = BuySListNode(x);
		//连接
		tail->next = newnode;
	}
}

void SListPushFront(SLTNode** pphead, SLTDataType x)
{
	assert(pphead);
	//创建一个新结点
	SLTNode* newnode = BuySListNode(x);
	//头插
	newnode->next = *pphead;
	*pphead = newnode;
}

void SListPopBack(SLTNode** pphead)
{
	assert(pphead);
	assert(*pphead);
	//单个结点
	if ((*pphead)->next == NULL)//->优先级比*高需要(*pphead)
	{
		free(*pphead);
		*pphead = NULL;
	}
	//多个结点
	else
	{
		SLTNode* prev = NULL;
		SLTNode* tail = *pphead;
		//找尾结点
		while (tail->next != NULL)
		{
			prev = tail;
			tail = tail->next;
		}
		//释放
		free(tail);
		prev->next = NULL;
	}
}

void SListPopFront(SLTNode** pphead)
{
	assert(pphead);
	assert(*pphead);
	SLTNode* next = (*pphead)->next;
	free(*pphead);
	(*pphead) = next;
}

int SListSize(SLTNode* phead)
{
	int size = 0;
	SLTNode* cur = phead;
	while (cur)
	{
		size++;
		cur = cur->next;
	}
	return size;
}

bool SListEmpty(SLTNode* phead)
{
	return phead == NULL;
}

SLTNode* SListFind(SLTNode* phead, SLTDataType x)
{
	SLTNode* cur = phead;
	while (cur)
	{
		if (cur->data == x)
		{
			return cur;
		}
		else
		{
			cur = cur->next;
		}
	}
	return NULL;
}

void SListInsert(SLTNode** pphead, SLTNode* pos, SLTDataType x)
{
	assert(pphead);
	assert(pos);
	//如果在第一个结点前插入就首插
	if (*pphead == pos)
	{
		SListPushFront(pphead, x);
	}
	else
	{
		//找到pos前一个结点
		SLTNode* prev = *pphead;
		while (prev->next != pos)
		{
			prev = prev->next;
		}
		SLTNode* newnode = BuySListNode(x);
		newnode->next = pos;
		prev->next = newnode;
	}
}

void SListInsertAfter(SLTNode* pos, SLTDataType x)
{
	assert(pos);
	SLTNode* newnode = BuySListNode(x);
	newnode->next = pos->next;
	pos->next = newnode;
}

void SListErase(SLTNode** pphead, SLTNode* pos)
{
	assert(pphead);
	assert(pos);
	//一个结点时相当于头删
	if (*pphead == pos)
	{
		SListPopFront(pphead);
	}
	else
	{
		SLTNode* prev = *pphead;
		while (prev->next != pos)
		{
			prev = prev->next;
		}
		prev->next = pos->next;
		free(pos);
		pos = NULL;
	}
}


void SListEraseAfter(SLTNode* pos)
{
	assert(pos);
	assert(pos->next);
	SLTNode* next = pos->next;
	pos->next = next->next;
	free(next);
	next = NULL;
}

void SListDestory(SLTNode** plist)
{
	assert(plist);
	SLTNode* cur = *plist;
	//将单链表依次销毁
	while (cur)
	{
		SLTNode* next = cur->next;
		free(cur);
		cur = next;
	}
	*plist = NULL;
}
小倪同学 -_-
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
数据结构之单链表实验
// 在校菜鸟大学生的日常学习博客
09-01 5821
单链表实验实验目的实验环境实验要求实验内容源代码运行结果 实验目的 掌握线性表的定义、特点、逻辑结构，理解线性表的抽象数据类型。 熟练掌握线性表的两种存储结构的结构类型定义、特点和基本操作的实现。 通过本次实验帮助学生加深对线性表的理解，并加以应用； 实验环境 CodeBlocks 实验要求 1.熟悉c语言的语法知识； 2.了解线性表的逻辑结构特性； 3.掌握线性表的链式存储结构—单链表的定义、创建、插入、删除、取值等基本操作； 实验内容 完成单链表的基本操作（定义、初始化、插入、删除、定位等）的汇总，
C数据结构_链表
hello呀！
01-27 561
1.定义链表 //无头单向非循环链表 typedef struct SListNode { int data; struct SListNode*next; }SListNode; typedef struct SList { SListNode*head; }SList; 2.链表基础功能的实现 //初始化 void Init(SList*p); //销毁 void Dest...
数据结构-链表（C语言+动态内存管理）
weixin_72501602的博客
05-08 418
无哨兵位单链表
链表初始化typedef struct LNode{}LNode,*linklist的理解
热门推荐
qq_43244452的博客
09-23 1万+
typedef在C中叫做声明别名，就是说同种事物的另外一个称谓，而C的别名代表的是typedef后面定义的所有内容，别名会写在最后，所以，}后面的Lnode和*LinkListdou’shi都是struct Lnode的别名，使用别名的目的就是为了让结构体更方便于理解和控制，以后在使用的时候就很方便了，比如创建一个头指针，没有别名之前的写法是 struct Lnode *head = (struc...
数据结构之单链表非常详细介绍(适合小白）
m0_74438843的博客
08-22 5243
数据结构深度学习之单链表非常详解解读~~~一万多字详解
数据结构之单链表（java版）
qq_42489613的博客
10-23 1408
数据结构就是用某种结构去储存数据
数据结构之单链表操作合集.zip
06-16
这个“数据结构之单链表操作合集.zip”文件显然是针对大学生学习数据结构而准备的资源，包含了丰富的学习材料。下面将详细讨论单链表的相关知识点。 单链表是一种线性数据结构，由一系列节点（也称为元素或记录）...
单链表-C++数据结构之单链表实现.zip
03-13
单链表是计算机科学中一种基础且重要的数据结构，它在C++中有着广泛的应用。在C++中实现单链表，需要理解链表的基本概念、节点结构以及相关的操作。以下是对这一主题的详细讲解： 1. **链表概念**： 链表是一种...
使用C++实现链表数据结构之单链表.zip
03-13
链表是一种基础且重要的数据结构，它在计算机科学中被广泛使用，特别是在处理动态数据集合时。本主题将深入探讨如何使用C++语言实现单链表。单链表是链表的一种基本形式，每个节点包含数据和指向下一个节点的指针。 ...
Python数据结构之单链表详解
09-21
### Python数据结构之单链表详解 #### 一、单链表基础概念 单链表是一种常见的线性数据结构，其特点是每个元素包含一个指向下一个元素的引用（指针），因此形成一个链接的数据序列。与数组相比，单链表的优势在于...
基于JAVA的数据结构之单链表操作合
03-25
单链表是一种基础且重要的数据结构，它在计算机科学中被广泛使用，特别是在编程语言如Java中。单链表由一系列节点组成，每个节点包含一个数据元素和一个指向下一个节点的引用。这种数据结构允许动态地添加、删除和...
typedef struct lnode(结构体及结构体指针)解惑
dhuqsh的博客
07-29 7176
/* 数据结构解惑01  在数据结构中会看到 typedef struct QNode { QElemType data; //数据域  struct QNode *next; //指针域  }QNode,*QueuePtr; typedef struct { QueuePtr front; //队头指针 QueuePtr rear; //队尾指针  };
数据结构：无头单向非循环链表C语言实现
weixin_51885188的博客
10-31 450
目录 链表的概念及结构 链表的分类 链表的实现 打印单链表 初始化链表 动态申请一个结点 单链表尾插 单链表头插 单链表尾删 单链表头删 单链表查找 单链表在pos位置之后插入x 单链表在pos位置之前去插入一个结点 单链表删除pos位置的结点 单链表删除pos位置之后的结点 单链表的销毁 链表的概念及结构 概念：链表是一种物理存储结构上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的，结点可以在运行的时候动态生成，每个结点包括两个部分：一个是
数据结构之---堆（2）
2301_81684056的博客
08-15 634
出堆是指将堆顶数据出堆。出堆完成后要保证剩余数据还是满足原来堆的性质。所以我们把堆顶数据和堆底最后一个数据交换，取出新堆底数据，之后通过向下调整算法将剩下的数据重新排列成一个堆。大堆经过出堆操作得出的数据是升序的小堆经过出堆操作得出的数据是降序的。
深入理解MySQL索引：原理、数据结构与优化策略
乙壳虫的博客
08-16 912
索引类似于一本书的目录，它可以帮助我们快速定位到需要的内容。没有索引时，MySQL 需要遍历整个表来找到目标记录，而索引通过构建特定的结构，可以加速查找的过程。索引的主要作用是提高数据库查询效率，减少数据库检索的行数，从而提升查询速度。B-Tree 索引：这是 MySQL 中最常见的索引结构，适用于大多数场景。B-Tree 是平衡树的一种，能够保持数据有序，从而加快查找速度。哈希索引（Hash Index）：通过将键映射为固定大小的哈希值来加速查找，适用于精确查找。
数据结构之树的存储结构
最新发布
DKPT的博客
08-16 574
孩子链表表示法将树中所有节点存储在一个顺序表中，每个数据元素有两个域：数据域和存放该节点第一个孩子地址的指针域。同时，为树中每个节点构建一个单链表，链表中的节点也有两个域：存放该孩子节点在顺序表中的数组下标和指向下一个孩子的指针。对于完全二叉树，如果父节点的索引是i（假设从0开始计数），那么它的左子节点的索引是2i+1，右子节点的索引是2i+2。数组的第一个元素存储树的根节点。双亲表示法通过采用一维数组来存储树中的节点，其中每个节点被赋予一个结构体类型，包含数据域和父节点位置域（parent域）。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值