1. Toy模板网首页
  2. > Toy博客

【数据结构】单链表的增删查改（C语言实现）

9月前 作者：野猪佩奇` 分类：Toy博客 阅读(56) 违法举报

这篇具有很好参考价值的文章主要介绍了【数据结构】单链表的增删查改（C语言实现）。希望对大家有所帮助。如果存在错误或未考虑完全的地方，请大家不吝赐教，您也可以点击"举报违法"按钮提交疑问。

前言

在上一节中我们提到了顺序表有如下缺陷：

在头部/中间的插入与删除需要挪动数据，时间复杂度为O(N)，效率低；

增容需要申请新空间，可能会拷贝数据，释放旧空间，会有不小的消耗；

增容一般是呈2倍的增长，势必会有一定的空间浪费。例如当前容量为100，满了以后增容到 200，如果我们再继续插入了5个数据，后面没有数据插入了，那么会浪费95个数据空间；

基于顺序表的这些不足，我们设计出了链表。

一、链表

1、链表的概念及结构

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

链表和顺序表的不同之处在于：顺序表不仅要求逻辑结构上也连续，还要求物理结构上连续；而链表只要求逻辑结构上连续，物理结构上可以不连续；

所谓的逻辑结构指的是数据在逻辑上是如何存储的，这是由人们主观想象出来的；而物理结构则是数据在物理内存中实际存储的方式，不随人们的主观意志而改变。

链表的结构图示如下：数据结构c语言单链表的查找与删除,数据结构初阶,数据结构,c语言,链表

从上面的图中我们也可以看出：链表在逻辑结构上连续指的是链表的每一个节点都记录着下一个节点的地址，我们可以根据此地址来找到链表的下一个节点，就好像它们被一根线连起来了一样；

而实际上链表的每一个节点都是在堆区上随机申请的，前一个节点的地址可能比后一个节点大，也可能比后一个节点小，二者之前其实并没有物理结构上的关系。

2、链表的分类

在实际应用中，链表根据带头/不带头、循环/不循环、双向/单向这三种选择一共可以组合出8种结构。

单向或者双向：双向链表对比单向链表来说，其结构体中会多一个结构体指针变量，用来指向前一个节点的地址。数据结构c语言单链表的查找与删除,数据结构初阶,数据结构,c语言,链表

带头或者不带头：带头与不带头其实区别就是链表最开始的时候会有一个节点，这个节点不用来存储数据，仅仅作为链表的头部使用，还是一个节点都没有。数据结构c语言单链表的查找与删除,数据结构初阶,数据结构,c语言,链表

循环或者非循环：非循环链表的最后一个节点的next指向NULL，而循环链表的最后一个节点的next指向链表的第一个节点。数据结构c语言单链表的查找与删除,数据结构初阶,数据结构,c语言,链表

3、最常用的两种链表

虽然链表有这么多中结构，但是我们实际中最常用还是以下两种结构：无头单向非循环链表和双向带头循环链表。

无头单向非循环链表

无头单向非循环链表结构最简单，一般不会单独用来存数据，实际中更多是作为其他数据结构的子结构，如哈希桶、图的邻接表等等；另外这种结构在笔试面试中出现很多；其实如果不做特殊声明，一般情况下无头单向非循环链表指的就是我们的单链表；

带头双向循环链表

带头双向循环链表结构最复杂，一般用于单独存储数据；实际中我们使用的链表数据结构，都是带头双向循环链表；另外它虽然结构复杂，但是使用代码实现后会有很多优势，所以反而是链表中使用起来最简单的。

二、单链表的实现

由于单链表是其他结构链表学习的基础，且经常被用做其他数据结构的子结构，在笔试题中也最常被考到，所以下面我们用C原因来手动实现一个单链表，以此来加强我们对单链表的理解。

1、结构的定义

实现，与顺序表一样，单链表也需要一个变量来data来记录数据，且我们应该对data的类型重命名，使得我们的链表可以管理不同类型的数据；其次，由于单链表中需要存储下一个节点的地址，所以我们应该有一个指向结构体的指针。

//符号和结构的声明
typedef int SLTDataType;  //数据类型重命名
typedef struct SListNode   //链表的一个节点
{
	SLTDataType data;
	struct SListNode* next;  //存放下一个节点的地址
}SLTNode;

2、创建新节点

由于单链表的每一个节点都需要单独开辟，所以我们可以把创建节点封装成一个函数，避免在头插、尾插、任意位置插入这些位置重复实现。

需要注意的是，由于我们这里实现的单链表是不带头的，即单链表一开始就是空的，所以我们并不需要对其进行初始化操作，只需要定义一个指向NULL的节点指针 plist 即可。

//创建新节点
SLTNode* BuySLTNode(SLTDataType x)
{
	SLTNode* newNode = (SLTNode*)malloc(sizeof(SLTNode));
	if (newNode == NULL)
	{
		perror("malloc fail");
		return NULL;  //如果malloc失败，返回NULL
	}
	newNode->data = x;
	newNode->next = NULL;
	return newNode;
}

3、在头部插入数据

特别注意：不管我们在什么地方插入数据，我们都需要传递二级指针，因为链表一开始是空的，所以我们在插入第一个数据的时候需要让 plist 指向我们新开辟的这一个节点，即头结点；而我们知道，要改变 int，需要传递 int*，要改变 int*，需要传递 int**，类比过来，这里的 plist 是一个结构体指针变量，我们想要改变它，让它从 NULL 变为第一个节点的地址，就需要传递结构体指针的地址，即二级指针才能实现。

其次，我们在改变节点中的next指针的时候使用的是结构体指针，即一级指针，而并没有用到二级指针，这是因为我们修改节点中的next是对结构体进行操作，而要改变结构体我们只需要使用结构体指针即可，而不用像上面修改结构体指针一样使用二级指针。

同时，结构体指针的地址是一定不为空的，因为即使是链表为空即 plis == NULL 的时候，&plist 也不等于空，所以我们需要对 pphead 进行断言，来保证代码的鲁棒性；而链表又是可能为空的，所以我们不需要对 *pphead (即 plist) 进行断言。

如果我们使用带头节点的单链表就不需要传递二级指针，因为不管我们如何对链表进行操作，头结点都始终不会改变。

//在头部插入数据
void SListPushFront(SLTNode** pphead, SLTDataType x)  //要改变plist，所以用二级指针来接收plist的地址
{
	assert(pphead);  //pphead为plist的地址，一定不为空
	//assert(*pphead);  //error：*pphead得到plist，而链表可能没有节点，所以plist可以为空，不用断言

	SLTNode* newNode = BuySLTNode(x);  //开辟新节点
	newNode->next = *pphead;
	*pphead = newNode;
}

4、在尾部插入数据

在尾部插入数据我们需要先找到的尾结点的前一个节点，因为我们需要让前一个节点的next指针指向新开辟的节点，然后让新开辟的节点的next指向尾结点，这样才能让我们的链表链接起来。

而我们的单链表只能找到下一个节点的地址，想要找到前一个节点需要从头开始遍历，所以单链表尾插的效率是比较低的，时间复杂度为O(N)，我们可以通过设计双向链表来解决这个问题。

//在尾部插入数据
void SListPushBack(SLTNode** pphead, SLTDataType x)
{
	assert(pphead);  //plist的地址一定不为空
	SLTNode* newNode = BuySLTNode(x);
	if (*pphead == NULL)  //如果链表为空
	{
		newNode->next = *pphead;
		*pphead = newNode;
		return;
	}

	//如果链表不为空，我们需要找到链表的尾
	SLTNode* tail = *pphead;
	while (tail->next != NULL)
	{
		tail = tail->next;
	}
	tail->next = newNode;
}

5、查找数据

查找数据不会改变头结点，所以我们只需要传递一级指针。

//查找数据
SLTNode* SListFind(SLTNode* phead, SLTDataType x)
{
	assert(phead);  //链表为空查找直接报错
	SLTNode* cur = phead;
	while (cur != NULL)
	{
		if (cur->data == x)
			return cur;  //找到返回节点地址
		cur = cur->next;
	}
	return NULL;  //找不到返回空
}

6、在pos位置前插入数据

和尾插一样，我们需要从头遍历链表，找到 pos 节点的前一个节点，让该节点的next指向新开辟的节点，使得链表成功链接。

//在pos位置前插入数据
void SListInsert(SLTNode** pphead, SLTNode* pos, SLTDataType x)
{
	assert(pphead);
	assert(pos);
	if (pos == *pphead)  //如果pos等于*pphead，相当于头插
	{
		SListPushFront(pphead, x);
		return;
	}

	SLTNode* newNode = BuySLTNode(x);
	//找到pos位置的前一个节点
	SLTNode* prev = *pphead;
	while (prev->next != pos)
	{
		assert(prev);  //如果prev为空循环还没停止，说明在链表中找不到pos，直接报错
		prev = prev->next;
	}
	prev->next = newNode;
	newNode->next = pos;
}

7、在pos位置后插入数据

由于单链表在某一节点的前面插入数据时需要从头遍历寻找该节点的前一个节点，导致时间复杂度为O(N)，所以人们为了提高单链表的效率，为单链表单独设计了在pos位置后插入数据的函数；除了单链表，其他数据结构插入数据都是在前面插入。

//在pos位置之后插入数据
void SListInsertAfter(SLTNode** pphead, SLTNode* pos, SLTDataType x)
{
	assert(pphead && pos);
	SLTNode* next = pos->next;
	SLTNode* newNode = BuySLTNode(x);
	pos->next = newNode;
	newNode->next = next;
}

8、在头部删除数据

特别注意： 和插入数据一样，因为我们删除的可能是链表中的最后一个数据，即可能会改变 plist 的指向 (让 plist 重新指向 NULL)，所以不管我们在什么地方删除数据，都需要传递二级指针。

其次，由于我们这里是删除数据，所以函数调用者需要保证调用此函数时链表中至少是含有一个数据的；所以我们对 *pphead (等价于 plist) 进行断言，当调用者错误使用此函数时，我们直接报错并介绍程序。

//在头部删除数据
void SListPopFront(SLTNode** pphead)
{
	assert(pphead);
	assert(*pphead);  //当链表为空时，删除元素报错
	SLTNode* tmp = (*pphead)->next;  //注意：* 和 -> 优先级一样，要加括号
	free(*pphead);
	*pphead = tmp;
}

9、在尾部删除数据

在尾部删除数据面临着和尾插一样的问题，需要改变前一个节点的next指针，所以时间复杂度也为O(N)。

//在尾部删除数据
void SListPopBack(SLTNode** pphead)
{
	assert(pphead);
	assert(*pphead);  //当链表为空时，删除元素报错
	if ((*pphead)->next == NULL)  //当链表只有一个元素时，相当于头删
	{
		SListPopFront(pphead);
		return;
	}
	//先找到链表的尾及其前一个节点
	SLTNode* cur = *pphead;
	SLTNode* prev = cur;
	while (cur->next != NULL)
	{
		prev = cur;
		cur = cur->next;
	}
	prev->next = NULL;
	free(cur);
	cur = NULL;
}

10、删除pos位置前的数据

//删除pos位置前的数据
void SListErase(SLTNode** pphead, SLTNode* pos)
{
	assert(pphead && pos);
	assert(*pphead);  //当链表为空时，删除元素报错
	if (pos == *pphead)  //pos等于*pphead时相当于头删
	{
		SListPopFront(pphead);
		return;
	}
	//找到pos的前一个节点
	SLTNode* prev = *pphead;
	while (prev->next != pos)
	{
		assert(prev);  //如果prev为空循环还没停止，说明在链表中找不到pos，直接报错
		prev = prev->next;
	}
	SLTNode* tmp = pos->next;
	prev->next = tmp;
	free(pos);
	pos = NULL;
}

11、删除pos位置后的数据

和在pos位置后插入数据一样，为了提高效率，人们也设计了一个在pos位置后删除数据的函数。

//删除pos位置后的数据
void SListEraseAfter(SLTNode** pphead, SLTNode* pos)
{
	assert(pphead && pos);
	assert(*pphead);  //当链表为空时，删除元素报错
	assert((*pphead)->next);  //当链表只有一个元素时，也不能调用此函数
	SLTNode* tmp = pos->next->next;
	free(pos->next);
	pos->next = tmp;
}

12、修改pos位置处的数据

修改数据也不会改变头指针，所以这里传一级指针；同时，为了保证代码的鲁棒性，我们这里对 phead 和 pos 断言一下。

//修改pos位置处的数据
void SListModify(SLTNode* phead, SLTNode* pos, SLTDataType x)
{
	assert(phead && pos);
	SLTNode* cur = phead;
	while (cur != pos)
	{
		assert(cur);  //如果cur为空循环还没停止，说明在链表中找不到pos，直接报错
		cur = cur->next;
	}
	cur->data = x;
}

13、打印链表中的数据

打印数据也不会改变头指针，所以这里传一级指针；但是这里和修改数据不一样的地方是，当链表为空的时候我们打印的逻辑也是正常的，只是说调用此函数什么都不打印而已，但是我们不能对其断言让其为空时报错。

//打印链表
void SListPrint(SLTNode* phead)  //打印不需要改变plist
{
	//不用对Phead进行断言，当链表为空时打印的逻辑是正常的
	SLTNode* cur = phead;
	while (cur != NULL)
	{
		printf("%d->", cur->data);  //-> 和 NULL 是为了让我们的链表更形象化
		cur = cur->next;
	}
	printf("NULL\n");
}

14、销毁链表

销毁链表需要将 plist 值为空，所以这里我们传递二级指针。

//销毁链表
void SListDestory(SLTNode** pphead)
{
	assert(pphead);
	SLTNode* cur = *pphead;
	while (cur != NULL)
	{
		SLTNode* tmp = cur->next;  //保存下一个节点的地方
		free(cur);  //释放
		cur = tmp;
	}
	*pphead = NULL;  //将plist置为空
}

三、完整代码

1、SList.h

#pragma once  //防止头文件重复包含

//头文件的包含
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>

//符号和结构的声明
typedef int SLTDataType;  //数据类型重命名
typedef struct SListNode   //链表的一个节点
{
	SLTDataType data;
	struct SListNode* next;  //存放下一个节点的地址
}SLTNode;

//函数的声明
//创建新建节点
SLTNode* BuySLTNode(SLTDataType x);
//在头部插入数据
void SListPushFront(SLTNode** pphead, SLTDataType x);
//销毁链表
void SListDestory(SLTNode** pphead);
//在尾部插入数据
void SListPushBack(SLTNode** pphead, SLTDataType x);
//查找数据
SLTNode* SListFind(SLTNode* phead, SLTDataType x);
//在pos之前插入数据
void SListInsert(SLTNode** pphead, SLTNode* pos, SLTDataType x);
//在pos之后插入数据
void SListInsertAfter(SLTNode** pphead, SLTNode* pos, SLTDataType x);
//打印链表
void SListPrint(SLTNode* phead);
//在头部删除数据
void SListPopFront(SLTNode** pphead);
//在尾部删除数据
void SListPopBack(SLTNode** pphead);
//删除pos位置处的数据
void SListErase(SLTNode** pphead, SLTNode* pos);
//删除pos位置后的数据
void SListEraseAfter(SLTNode** pphead, SLTNode* pos);
//修改pos位置处的函数
void SListModify(SLTNode* phead, SLTNode* pos, SLTDataType x);

2、SList.c

#define _CRT_SECURE_NO_WARNINGS 1
#include "SList.h"

//创建新节点
SLTNode* BuySLTNode(SLTDataType x)
{
	SLTNode* newNode = (SLTNode*)malloc(sizeof(SLTNode));
	if (newNode == NULL)
	{
		perror("malloc fail");
		return NULL;  //如果malloc失败，返回NULL
	}
	newNode->data = x;
	newNode->next = NULL;
	return newNode;
}

//销毁链表
void SListDestory(SLTNode** pphead)
{
	assert(pphead);
	SLTNode* cur = *pphead;
	while (cur != NULL)
	{
		SLTNode* tmp = cur->next;  //保存下一个节点的地方
		free(cur);  //释放
		cur = tmp;
	}
	*pphead = NULL;  //将plist置为空
}

//在头部插入数据
void SListPushFront(SLTNode** pphead, SLTDataType x)  //要改变plist，所以用二级指针来接收plist的地址
{
	assert(pphead);  //pphead为plist的地址，一定不为空
	//assert(*pphead);  //error：*pphead得到plist，而链表可能没有节点，所以plist可以为空，不用断言

	SLTNode* newNode = BuySLTNode(x);  //开辟新节点
	newNode->next = *pphead;
	*pphead = newNode;
}

//打印链表
void SListPrint(SLTNode* phead)  //打印不需要改变plist
{
	//不用对Phead进行断言，当链表为空时打印的逻辑是正常的
	SLTNode* cur = phead;
	while (cur != NULL)
	{
		printf("%d->", cur->data);  //-> 和 NULL 是为了让我们的链表更形象化
		cur = cur->next;
	}
	printf("NULL\n");
}

//在尾部插入数据
void SListPushBack(SLTNode** pphead, SLTDataType x)
{
	assert(pphead);  //plist的地址一定不为空
	SLTNode* newNode = BuySLTNode(x);
	if (*pphead == NULL)  //如果链表为空
	{
		newNode->next = *pphead;
		*pphead = newNode;
		return;
	}

	//如果链表不为空，我们需要找到链表的尾
	SLTNode* tail = *pphead;
	while (tail->next != NULL)
	{
		tail = tail->next;
	}
	tail->next = newNode;
}

//查找数据
SLTNode* SListFind(SLTNode* phead, SLTDataType x)
{
	assert(phead);  //链表为空查找直接报错
	SLTNode* cur = phead;
	while (cur != NULL)
	{
		if (cur->data == x)
			return cur;  //找到返回节点地址
		cur = cur->next;
	}
	return NULL;  //找不到返回空
}

//在pos位置前插入数据
void SListInsert(SLTNode** pphead, SLTNode* pos, SLTDataType x)
{
	assert(pphead);
	assert(pos);
	if (pos == *pphead)  //如果pos等于*pphead，相当于头插
	{
		SListPushFront(pphead, x);
		return;
	}

	SLTNode* newNode = BuySLTNode(x);
	//找到pos位置的前一个节点
	SLTNode* prev = *pphead;
	while (prev->next != pos)
	{
		assert(prev);  //如果prev为空循环还没停止，说明在链表中找不到pos，直接报错
		prev = prev->next;
	}
	prev->next = newNode;
	newNode->next = pos;
}

//在pos位置之后插入数据
void SListInsertAfter(SLTNode** pphead, SLTNode* pos, SLTDataType x)
{
	assert(pphead && pos);
	SLTNode* next = pos->next;
	SLTNode* newNode = BuySLTNode(x);
	pos->next = newNode;
	newNode->next = next;
}

//在头部删除数据
void SListPopFront(SLTNode** pphead)
{
	assert(pphead);
	assert(*pphead);  //当链表为空时，删除元素报错
	SLTNode* tmp = (*pphead)->next;  //注意：* 和 -> 优先级一样，要加括号
	free(*pphead);
	*pphead = tmp;
}

//在尾部删除数据
void SListPopBack(SLTNode** pphead)
{
	assert(pphead);
	assert(*pphead);  //当链表为空时，删除元素报错
	if ((*pphead)->next == NULL)  //当链表只有一个元素时，相当于头删
	{
		SListPopFront(pphead);
		return;
	}
	//先找到链表的尾及其前一个节点
	SLTNode* cur = *pphead;
	SLTNode* prev = cur;
	while (cur->next != NULL)
	{
		prev = cur;
		cur = cur->next;
	}
	prev->next = NULL;
	free(cur);
	cur = NULL;
}

//删除pos位置处的数据
void SListErase(SLTNode** pphead, SLTNode* pos)
{
	assert(pphead && pos);
	assert(*pphead);  //当链表为空时，删除元素报错
	if (pos == *pphead)  //pos等于*pphead时相当于头删
	{
		SListPopFront(pphead);
		return;
	}
	//找到pos的前一个节点
	SLTNode* prev = *pphead;
	while (prev->next != pos)
	{
		assert(prev);  //如果prev为空循环还没停止，说明在链表中找不到pos，直接报错
		prev = prev->next;
	}
	SLTNode* tmp = pos->next;
	prev->next = tmp;
	free(pos);
	pos = NULL;
}

//删除pos位置后的数据
void SListEraseAfter(SLTNode** pphead, SLTNode* pos)
{
	assert(pphead && pos);
	assert(*pphead);  //当链表为空时，删除元素报错
	assert((*pphead)->next);  //当链表只有一个元素时，也不能调用此函数
	SLTNode* tmp = pos->next->next;
	free(pos->next);
	pos->next = tmp;
}

//修改pos位置处的数据
void SListModify(SLTNode* phead, SLTNode* pos, SLTDataType x)
{
	assert(phead && pos);
	SLTNode* cur = phead;
	while (cur != pos)
	{
		assert(cur);  //如果cur为空循环还没停止，说明在链表中找不到pos，直接报错
		cur = cur->next;
	}
	cur->data = x;
}

3、test.c

#define _CRT_SECURE_NO_WARNINGS 1
#include "SList.h"

void test1()   //测试插入
{
	SLTNode* plist = NULL;  //指向链表第一个节点的指针，因为链表没有节点，所以初始化为NULL；

	//头插
	SListPushFront(&plist, 1);
	SListPushFront(&plist, 2);
	SListPushFront(&plist, 3);
	SListPrint(plist);

	//尾插
	SListPushBack(&plist, 4);
	SListPushBack(&plist, 5);
	SListPushBack(&plist, 6);
	SListPrint(plist);

	//在pos位置前插入
	SLTNode* pos = SListFind(plist, 5);
	if (pos != NULL)
	{
		SListInsert(&plist, pos, 50);
	}
	pos = SListFind(plist, 3);
	if (pos != NULL)
	{
		SListInsert(&plist, pos, 30);
	}
	SListPrint(plist);

	pos = SListFind(plist, 6);
	if (pos != NULL)
	{
		SListInsert(&plist, pos, 60);
	}
	SListPrint(plist);

	//在pos位置后插入
	pos = SListFind(plist, 1);
	if (pos != NULL)
	{
		SListInsertAfter(&plist, pos, 10);
	}
	pos = SListFind(plist, 3);
	if (pos != NULL)
	{
		SListInsertAfter(&plist, pos, 30);
	}
	SListPrint(plist);

	//销毁
	SListDestory(&plist);
}

void test2()  //测试删除
{
	SLTNode* plist = NULL;  //指向链表第一个节点的指针，因为链表没有节点，所以初始化为NULL；

	//头插
	SListPushFront(&plist, 1);
	SListPushFront(&plist, 2);
	SListPushFront(&plist, 3);
	SListPrint(plist);

	//在头部删除数据
	//SListPopFront(&plist);
	//SListPopFront(&plist);
	//SListPopFront(&plist);
	//SListPrint(plist);

	//在尾部删除数据
	//SListPopBack(&plist);
	//SListPopBack(&plist);
	//SListPopBack(&plist);
	//SListPrint(plist);

	//删除pos位置处的数据
	//SLTNode* pos = SListFind(plist, 1);
	//if (pos != NULL)
	//{
	//	SListErase(&plist, pos);
	//}
	//pos = SListFind(plist, 3);
	//if (pos != NULL)
	//{
	//	SListErase(&plist, pos);
	//}
	//SListPrint(plist);
	//pos = SListFind(plist, 2);
	//if (pos != NULL)
	//{
	//	SListErase(&plist, pos);
	//}
	//SListPrint(plist);

	//删除pos位置后的数据
	SLTNode* pos = SListFind(plist, 2);
	if (pos != NULL)
	{
		SListEraseAfter(&plist, pos);
	}
	SListPrint(plist);
	pos = SListFind(plist, 3);
	if (pos != NULL)
	{
		SListEraseAfter(&plist, pos);
	}
	SListPrint(plist);

	//销毁
	SListDestory(&plist);
}

void test3()  //测试查和改
{
	SLTNode* plist = NULL;  //指向链表第一个节点的指针，因为链表没有节点，所以初始化为NULL；

	//头插
	SListPushFront(&plist, 1);
	SListPushFront(&plist, 2);
	SListPushFront(&plist, 3);
	SListPrint(plist);

	//查找并修改pos位置处的数据
	SLTNode* pos = SListFind(plist, 3);
	if (pos != NULL)
	{
		SListModify(plist, pos, 30);
	}
	SListPrint(plist);
	pos = SListFind(plist, 1);
	if (pos != NULL)
	{
		SListModify(plist, pos, 10);
	}
	SListPrint(plist);

	//销毁
	SListDestory(&plist);
}

int main()
{
	//test1();  //测试插入
	//test2();  //测试删除
	test3();  //测试查和改
}

大家也可以去我的 Gitee 仓库中获取完整代码：SList/SList · 野猪佩奇/日常学习 - 码云 - 开源中国 (gitee.com)文章来源地址https://www.toymoban.com/news/detail-739393.html

到了这里，关于【数据结构】单链表的增删查改（C语言实现）的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处： 如若内容造成侵权/违法违规/事实不符，请点击违法举报进行投诉反馈，一经查实，立即删除！

分享到：
领支付宝红包 赞助服务器费用

相关文章

  • 数据结构之顺序表的增删查改

    数据结构之顺序表的增删查改

    自今日起，我们正式 越过C语言的大山 ，走向了 数据结构的深山 ，现如今摆在我们面前的第一个坎就是 顺序表 ，我们需要了解顺序表的 定义 ，并且知道，如何对其进行 增删查改 ，之后我们需要在此处基础上写出一份 通讯录代码 ，ok，顺序表，启动！ 线性表（ linear lis

    2024年01月23日
    浏览(69)
  • 【数据结构】链表：带头双向循环链表的增删查改

    【数据结构】链表：带头双向循环链表的增删查改

    本篇要分享的内容是带头双向链表，以下为本片目录 目录 一、链表的所有结构 二、带头双向链表 2.1尾部插入 2.2哨兵位的初始化 2.3头部插入 2.4 打印链表 2.5尾部删除 2.6头部删除  2.7查找结点 2.8任意位置插入 2.9任意位置删除  在刚开始接触链表的时候，我们所学仅仅所学的

    2024年02月05日
    浏览(89)
  • 【数据结构】双向链表的增删查改（C 代码实现）

    【数据结构】双向链表的增删查改（C 代码实现）

    引入双向链表：关于单链表的问题与讨论 单链表存在的毛病： 因为单链表 只能单向 遍历链表， 对于 前插 这个操作，单链表必 须得找到所需前插节点位置的前一个 ，那么这时就得 从头指针重新遍历一次 链表，会造成时间复杂度大大增加。 没有头节点（哨兵位）无法删除

    2024年02月08日
    浏览(51)
  • 【数据结构】实现单链表的增删查

    【数据结构】实现单链表的增删查

    链表类和节点类的定义： 图解： 从中间位置插入： 图解：假定index=2 尾插： 删除当前线性表中索引为index的元素，返回删除的元素值： 图解： 删除当前线性表中第一个值为element的元素： 删除当前线性表中所有值为element的元素： 将当前线性表中index位置的元素替换为eleme

    2024年02月14日
    浏览(144)
  • 【数据结构】单向链表的增删查改以及指定pos位置的插入删除

    【数据结构】单向链表的增删查改以及指定pos位置的插入删除

    目录  单向链表的概念及结构  尾插 头插 尾删 ​编辑  头删  查找  在pos位置前插  在pos位置后插  删除pos位置  删除pos的后一个位置 总结 代码  概念：链表是一种 物理存储结构上非连续 、非顺序的存储结构，数据元素的 逻辑顺序 是通过链表中的 指针链接 次序实现的

    2024年02月05日
    浏览(47)

  • C语言数据结构：双向循环链表的增删操作

    2024年04月25日
    浏览(51)
  • 数据结构：单链表的实现(C语言)

    数据结构：单链表的实现(C语言)

    个人主页 ： 水月梦镜花 个人专栏 ： 《C语言》 《数据结构》 本博客将要实现的无头单向不循环链表。 我们将节点定义为如下结构： 其成员变量有data，next。 将int重命名为STLDataType，方便我们以后修改数据域的内容。 动态申明一个空间，来放置数据。如下： 将data的内容置

    2024年02月14日
    浏览(56)
  • 数据结构——单链表的实现(c语言版）

    数据结构——单链表的实现(c语言版）

    前言           单链表作为顺序表的一种，了解并且熟悉它的结构对于我们学习更加复杂的数据结构是有一定意义的。虽然单链表有一定的缺陷，但是单链表也有它存在的价值， 它也是作为其他数据结构的一部分出现的，比如在图，哈希表中。 目录 1.链表节点的结构 2.头插

    2024年02月13日
    浏览(57)
  • [C语言][数据结构][链表] 单链表的从零实现!

    [C语言][数据结构][链表] 单链表的从零实现!

    目录 零.必备知识 1.一级指针 二级指针 2. 节点的成员列表     a.数据     b.指向下一个节点的指针. 3. 动态内存空间的开辟 (malloc-calloc-realloc) 一.单链表的实现与销毁          1.1 节点的定义         1.2 单链表的尾插         1.3 单链表的头插         1.4 单链表的尾删  

    2024年04月11日
    浏览(72)
  • 【数据结构】C语言实现单链表的基本操作

    【数据结构】C语言实现单链表的基本操作

    大家好，很高兴又和大家见面啦！！！ 在上一篇中，我们详细介绍了单链表的两种创建方式——头插法与尾插法，相信大家现在对这两种方式都已经掌握了。今天咱们将继续介绍单链表的基本操作——查找、插入与删除。在开始今天的内容之前，我们先通过尾插法创建一个单

    2024年02月03日
    浏览(63)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包，优惠每天领

二维码1

领取红包

二维码2

领红包