单链表的定义与基本操作

最新推荐文章于 2024-05-14 21:06:22 发布
最新推荐文章于 2024-05-14 21:06:22 发布
阅读量410 收藏
点赞数 3
分类专栏： 数据结构初阶（C语言） 文章标签： 链表 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/suyuzho/article/details/128623902
版权

单链表

文章目录

一、顺序表的缺陷

在之前的博客中，我介绍了动态顺序表的使用，但动态顺序表存在着以下缺陷。

  • 空间不够时需要扩容。会存在一定的空间浪费
  • 头部或中部的插入删除，需要频繁的挪动数据，效率低下。

而链表就可以很好的解决以上缺陷。（当然，链表不可以完全取代顺序表）链表分为很多种，这篇博客的介绍的是不带头的单向不循环链表。

二、单链表的结构定义

在这里插入图片描述
如图所示，可以看出，链表的每个节点由两部分组成，存储数据的data和指向下一个节点的next，于是有如下的链表的结构体定义。

typedef int SLTDataType;

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

三、单链表的基本操作

1.动态申请一个结点

使用malloc函数动态申请内存创造一个节点，节点的data置为传入的数值，next置为空

SLTNode* BuySLTNode(SLTDataType x)
{
	SLTNode* newnode = (SLTNode*)malloc(sizeof(SLTNode)); // malloc函数动态申请空间
	if (newnode == NULL) // 如果开辟失败就报错并结束程序运行
	{
		perror("malloc fail");
		exit(-1);
	}
	newnode->data = x;
	newnode->next = NULL;
	return newnode;
}

2.建立一个定长的单链表

根据传入的参数n，建立一个定长的单链表

SLTNode* CreateSList(int n)
{
	SLTNode* phead = NULL, * ptail = NULL; // phead用于指向头节点，ptail用于指向最后一个节点
	for (int i = 0; i < n; i++)
	{
		SLTNode* newnode = BuySLTNode(i); // 调用BuySLTNode函数，返回一个已经开辟好的，data为x，next为NULL的空间
		if (phead == NULL) // 如果phead为空，也就是说是第一次赋值
		{
			ptail = phead = newnode; // 将ptail，phead全部赋值为newnode
		}
		else
		{
			ptail->next = newnode; // ptail的下一个节点为newnode
			ptail = newnode; // 将ptail赋值为newnode
		}
	}
	return phead; // 返回链表的头节点
}

3.打印

传入头节点，通过next指针遍历单链表，打印节点中data的值。

void SLTPrint(SLTNode* phead)
{
	SLTNode* cur = phead; // 头节点赋值给cur（一般函数传入的值不要轻易改变，因为无法确定还会不会用到，
	// 使用哪个变量存储，再改变那个变量的值是一种不错的方法）
	while (cur != NULL) // cur不为空，说明还没有遍历结束
	{
		printf("%d ", cur->data); 
		cur = cur->next;
	}
	printf("\n");
}

4.尾插

在单链表的最后插入一个节点，首先使用BuySLTNode申请节点newnode，如果*pphead为空，那么将其赋值为newnode，如果不为空，定义一个节点指向单链表的头，通过next指向下一个节点，不断循环直到最后一个节点。最后使尾节点的next指向申请的newnode节点。

void SLTPushBack(SLTNode** pphead, SLTDataType x)
{
	SLTNode* newnode = BuySLTNode(x); // 动态申请节点
	if (*pphead == NULL) // 如果单链表为空
	{
		*pphead = newnode; // 单链表的头节点为newnode
	}
	else
	{
		SLTNode* tail = *pphead; // tail指向单链表的头节点
		while (tail->next != NULL) // tail还没有指向尾节点
		{
			tail = tail->next; // tail指向下一个节点
		}
		tail->next = newnode; // 此时的tail已经是最后一个节点，使其的next指向之前开辟好的newnode
	}
}

5.尾删

删除单链表的尾节点，首先需要使用assert函数确保传入的二级指针指向的一级指针不为空，然后分类讨论，如果单链表只有一个节点，那么删除该节点，*pphead为空，如果不止一个节点，需要找到尾节点的前一个节点，用free函数将尾节点释放，然后使尾节点的前一个节点指向空。

void SLTPopBack(SLTNode** pphead)
{
	assert(*pphead); // 确定*pphead不为空指针

	if ((*pphead)->next == NULL) // 单链表只有一个元素，*pphead指向尾节点
	{
		free(*pphead);
		*pphead = NULL;
	}
	else
	{
		SLTNode* tail = *pphead; 
		while (tail->next->next) // 使用tail找到尾节点的前一个节点
		{
			tail = tail->next;
		}
		free(tail->next); // 释放tail->next，也就是尾节点
		tail->next = NULL; // 使尾节点的前一个节点指向空
	}
}

6.头插

在单链表的最前面插入数据，首先是动态申请一个节点newnode，使该节点的next指向pphead，在将pphead赋值为newnode（这样newnode就作为头节点了）

void SLTPushFront(SLTNode** pphead, SLTDataType x)
{
	SLTNode* newnode = BuySLTNode(x); // 使用前面的函数动态申请节点
	newnode->next = *pphead; // 将newnode节点放在*pphead的前面
	*pphead = newnode; // *pphead赋值为newnode，newnode作为头节点
}

7.头删

删除单链表的第一个数据

void SLTPopFront(SLTNode** pphead)
{
	assert(*pphead); // 确保指针不为空

	SLTNode* next = (*pphead)->next; // 保存头节点的后一个节点
	free(*pphead); // 删除头节点
	*pphead = next; // 将*pphead赋值为头节点的下一个节点，这样该节点就成为了新的头节点
}

8.寻找指定元素的指针

给定一个数值，找出该数值在单链表的节点，如果单链表中存在这个数值，返回指向该节点的指针。不存在则返回空指针NULL。

SLTNode* SLTFind(SLTNode* phead, SLTDataType x)
{
	SLTNode* cur = phead; 
	while (cur != NULL) // 遍历单链表
	{
		if (cur->data == x) // 找到符合条件的指针
		{
			return cur; // 返回该指针
		}
		else
		{
			cur = cur->next;
		}
	}
	return NULL; // 循环结束，说明没有找到该元素对应的指针，返回空指针
}

9.在指定位置之后插入元素

在指定位置之后插入数据，首先要确保传入的pos位置不可以是空指针，这里可以使用assert断言。然后既然是插入，先动态申请节点，再改变相关指针的next指向即可。

void SLTInsertAfter(SLTNode* pos, SLTDataType x)
{
	assert(pos); // 确保pos不为空指针
	SLTNode* newnode = BuySLTNode(x); // 动态申请节点
	SLTNode* next = pos->next; // 保存pos的下一个节点，避免改变pos的next指针后无法找到原先pos的下一个节点
	pos->next = newnode; 
	newnode->next = next; 
}

10.在指定位置之前插入元素

在指定位置之前插入元素，先确保相关指针不为空。如果是该位置是头节点，就相当于头插，可以直接调用头插函数，如果不是，先利用头节点找到指定节点的前一个节点，在插入newnode节点

void SLTInsert(SLTNode** pphead, SLTNode* pos, SLTDataType x)
{
	assert(pos);
	assert(*pphead);
	if (*pphead == pos) // 在头节点之前插入，相当于头插，可以直接调用相关函数
	{
		SLTPushFront(pphead, x);
	}
	else
	{
		SLTNode* prev = *pphead;
		while (prev->next != pos) // 寻找pos的前面一个节点
		{
			prev = prev->next;
		}
		SLTNode* newnode = BuySLTNode(x);

		prev->next = newnode; // 插入newnode
		newnode->next = pos;
	}
}

11.删除指定位置之后的数据

如果这个位置是尾节点，说明后面没有数据可删，直接返回即可。如果不是，改变相关节点的next指针即可，和前面的头删有一点类似。

void SLTEraseAfter(SLTNode* pos)
{
	assert(pos); // 确保不是空指针
	if (pos->next == NULL) // pos为最后一个节点，后面没有数据可删
	{
		return;
	}
	else
	{
		SLTNode* nextNode = pos->next; // 保存下一个节点
		pos->next = nextNode->next; // 改变next指针关系
		free(nextNode); // 释放节点
	}
}

12.删除指定位置的指针

和上面有些类似，不过需要找到指定位置的前一个节点

void SLTErase(SLTNode** pphead, SLTNode* pos)
{
	assert(pos); // 确保指针不为空

	if (pos == *pphead) // 指定位置是头节点，相当于头删
	{
		SLTPopFront(pphead);
	}
	else
	{
		SLTNode* prev = *pphead; 
		while (prev->next != pos) // 遍历，找指定位置的前面一个节点
		{
			prev = prev->next;
		}
		prev->next = pos->next;
		free(pos); // 删除指定位置
	}
}

13.销毁单链表

删除单链表的每一个节点

void SLTDestroy(SLTNode** pphead)
{
	SLTNode* cur = *pphead; // 保存头节点
	while (cur) // 遍历单链表
	{
		SLTNode* next = cur->next; // 保存下一个节点
		free(cur); // 删除
		cur = next;
	}
	*pphead = NULL; // 置为空
}

四、总代码

代码中我没有写main函数

#define _CRT_SECURE_NO_WARNINGS 1

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

typedef int SLTDataType;

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

#include"SList.h"

SLTNode* BuySLTNode(SLTDataType x)
{
	SLTNode* newnode = (SLTNode*)malloc(sizeof(SLTNode)); // malloc函数动态申请空间
	if (newnode == NULL) // 如果开辟失败就报错并结束程序运行
	{
		perror("malloc fail");
		exit(-1);
	}
	newnode->data = x;
	newnode->next = NULL;
	return newnode;
}

SLTNode* CreateSList(int n)
{
	SLTNode* phead = NULL, * ptail = NULL; // phead用于指向头节点，ptail用于指向最后一个节点
	for (int i = 0; i < n; i++)
	{
		SLTNode* newnode = BuySLTNode(i); // 调用BuySLTNode函数，返回一个已经开辟好的，data为x，next为NULL的空间
		if (phead == NULL) // 如果phead为空，也就是说是第一次赋值
		{
			ptail = phead = newnode; // 将ptail，phead全部赋值为newnode
		}
		else
		{
			ptail->next = newnode; // ptail的下一个节点为newnode
			ptail = newnode; // 将ptail赋值为newnode
		}
	}
	return phead; // 返回链表的头节点
}

void SLTPrint(SLTNode* phead)
{
	SLTNode* cur = phead; // 头节点赋值给cur（一般函数传入的值不要轻易改变，因为无法确定还会不会用到，
	// 使用哪个变量存储，再改变那个变量的值是一种不错的方法）
	while (cur != NULL) // cur不为空，说明还没有遍历结束
	{
		printf("%d ", cur->data);
		cur = cur->next;
	}
	printf("\n");
}

void SLTPushBack(SLTNode** pphead, SLTDataType x)
{
	SLTNode* newnode = BuySLTNode(x); // 动态申请节点
	if (*pphead == NULL) // 如果单链表为空
	{
		*pphead = newnode; // 单链表的头节点为newnode
	}
	else
	{
		SLTNode* tail = *pphead; // tail指向单链表的头节点
		while (tail->next != NULL) // tail还没有指向尾节点
		{
			tail = tail->next; // tail指向下一个节点
		}
		tail->next = newnode; // 此时的tail已经是最后一个节点，使其的next指向之前开辟好的newnode
	}
}

void SLTPopBack(SLTNode** pphead)
{
	assert(*pphead); // 确定*pphead不为空指针

	if ((*pphead)->next == NULL) // 单链表只有一个元素，*pphead指向尾节点
	{
		free(*pphead);
		*pphead = NULL;
	}
	else
	{
		SLTNode* tail = *pphead;
		while (tail->next->next) // 使用tail找到尾节点的前一个节点
		{
			tail = tail->next;
		}
		free(tail->next); // 释放tail->next，也就是尾节点
		tail->next = NULL; // 使尾节点的前一个节点指向空
	}
}

void SLTPushFront(SLTNode** pphead, SLTDataType x)
{
	SLTNode* newnode = BuySLTNode(x); // 使用前面的函数动态申请节点
	newnode->next = *pphead; // 将newnode节点放在*pphead的前面
	*pphead = newnode; // *pphead赋值为newnode，newnode作为头节点
}

void SLTPopFront(SLTNode** pphead)
{
	assert(*pphead); // 确保指针不为空

	SLTNode* next = (*pphead)->next; // 保存头节点的后一个节点
	free(*pphead); // 删除头节点
	*pphead = next; // 将*pphead赋值为头节点的下一个节点，这样该节点就成为了新的头节点
}

SLTNode* SLTFind(SLTNode* phead, SLTDataType x)
{
	SLTNode* cur = phead;
	while (cur != NULL) // 遍历单链表
	{
		if (cur->data == x) // 找到符合条件的指针
		{
			return cur; // 返回该指针
		}
		else
		{
			cur = cur->next;
		}
	}
	return NULL; // 循环结束，说明没有找到该元素对应的指针，返回空指针
}

void SLTInsertAfter(SLTNode* pos, SLTDataType x)
{
	assert(pos); // 确保pos不为空指针
	SLTNode* newnode = BuySLTNode(x); // 动态申请节点
	SLTNode* next = pos->next; // 保存pos的下一个节点，避免改变pos的next指针后无法找到原先pos的下一个节点
	pos->next = newnode;
	newnode->next = next;
}

void SLTInsert(SLTNode** pphead, SLTNode* pos, SLTDataType x)
{
	assert(pos);
	assert(*pphead);
	if (*pphead == pos) // 在头节点之前插入，相当于头插，可以直接调用相关函数
	{
		SLTPushFront(pphead, x);
	}
	else
	{
		SLTNode* prev = *pphead;
		while (prev->next != pos) // 寻找pos的前面一个节点
		{
			prev = prev->next;
		}
		SLTNode* newnode = BuySLTNode(x);

		prev->next = newnode; // 插入newnode
		newnode->next = pos;
	}
}

void SLTEraseAfter(SLTNode* pos)
{
	assert(pos); // 确保不是空指针
	if (pos->next == NULL) // pos为最后一个节点，后面没有数据可删
	{
		return;
	}
	else
	{
		SLTNode* nextNode = pos->next; // 保存下一个节点
		pos->next = nextNode->next; // 改变next指针关系
		free(nextNode); // 释放节点
	}
}

void SLTErase(SLTNode** pphead, SLTNode* pos)
{
	assert(pos); // 确保指针不为空

	if (pos == *pphead) // 指定位置是头节点，相当于头删
	{
		SLTPopFront(pphead);
	}
	else
	{
		SLTNode* prev = *pphead;
		while (prev->next != pos) // 遍历，找指定位置的前面一个节点
		{
			prev = prev->next;
		}
		prev->next = pos->next;
		free(pos); // 删除指定位置
	}
}

void SLTDestroy(SLTNode** pphead)
{
	SLTNode* cur = *pphead; // 保存头节点
	while (cur) // 遍历单链表
	{
		SLTNode* next = cur->next; // 保存下一个节点
		free(cur); // 删除
		cur = next;
	}
	*pphead = NULL; // 置为空
}

测试案例（仅供参考）

void TestSList1()
{
	SLTNode* plist = NULL;
	SLTPushBack(&plist, 3);
	SLTPushBack(&plist, 4);
	SLTPrint(plist);
	SLTPopBack(&plist);
	SLTPrint(plist);
	SLTPushFront(&plist, 2);
	SLTPushFront(&plist, 1);
	SLTPrint(plist);
}

void TestSList2()
{
	SLTNode* plist = NULL;
	SLTPushBack(&plist, 1);
	SLTPushBack(&plist, 2);
	SLTPushBack(&plist, 3);
	SLTPushBack(&plist, 6);
	SLTPushBack(&plist, 7);
	SLTNode* pos = SLTFind(plist, 3);
	if (pos)
	{
		SLTInsertAfter(pos, 4);
	}
	else
	{
		printf("找不到\n");
	}
	pos = SLTFind(plist, 4);
	if (pos)
	{
		SLTInsertAfter(pos, 5);
	}
	else
	{
		printf("找不到\n");
	}
	pos = SLTFind(plist, 1);
	if (pos)
	{
		SLTInsertAfter(pos, 20);
	}
	else
	{
		printf("找不到\n");
	}
	pos = SLTFind(plist, 7);
	if (pos)
	{
		SLTInsertAfter(pos, 8);
	}
	else
	{
		printf("找不到\n");
	}
	SLTPrint(plist);
}

void TestSList3()
{
	SLTNode* plist = NULL;
	SLTPushBack(&plist, 2);
	SLTPushBack(&plist, 3);
	SLTPushBack(&plist, 4);
	SLTPushBack(&plist, 6);
	SLTNode* pos = SLTFind(plist, 2);
	SLTInsert(&plist, pos, 1);
	pos = SLTFind(plist, 6);
	SLTInsert(&plist, pos, 5);
	SLTPrint(plist);
	pos = SLTFind(plist, 3);
	SLTEraseAfter(pos);
	SLTPrint(plist);
}

void TestSList4()
{
	SLTNode* plist = NULL;
	SLTPushBack(&plist, 2);
	SLTPushBack(&plist, 3);
	SLTPushBack(&plist, 4);
	SLTPushBack(&plist, 6);
	SLTPrint(plist);
	SLTNode* pos = SLTFind(plist, 3);
	SLTErase(&plist, pos);
	SLTPrint(plist);
	SLTDestroy(&plist);
	SLTPrint(plist);
}

int main()
{
	/*TestSList1();*/
	/*TestSList2();*/
	/*TestSList3();*/
	TestSList4();
	return 0;
}
羽舟_
关注
  • 3
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
3-2单链表的基本操作1
08-03
单链表基本操作的 C++代码// 单链表的构造函数, 生成一个只有哨位结点的空表// 创建哨位结点// 单链表的构造函数, 生成含有哨位结点和一个表结点的表//
单链表的基本操作
12-04
此源码基于C语言，涉及到单链表的定义初始化以及增删查改，可直接运行。
单链表基本操作
qq_24624539的博客
11-05 1万+
1单链表基本操作(5分) 请编写程序实现单链表插入、删除结点等基本算法。给定一个单链表和一系列插入、删除结点的操作序列，输出实施上述操作后的链表。单链表数据域值为整数。 输入格式: 输入第1行为1个正整数n，表示当前单链表长度；第2行为n个空格间隔的整数，为该链表n个元素的数据域值。第3行为1个正整数m，表示对该链表施加的操作数量；接下来m行，每行表示一个操作，为2个或3个整数，格式为0 k d或1 k。0 k d表示在链表第k个结点后插入一个数据域值为d的结点，若k=0则表示表头插入。1 k表示..
【DS】链表基本操作
CHAOQIWEN的博客
05-12 182
1、头插 如果原链表不为空，要插入的节点的下一个节点就是原来链表的头节点，新链表的头节点就是要插入的节点； 如果原链表为空，直接插入，头节点就是要插入的节点 public void pushFront(Node node){ if(head!=null) { node.next = this.head; this.head=nod...
什么是单链表一
m0_60226024的博客
08-06 1706
1. 单链表概念&设计 单链表是一种链式存取的数据结构，，链表中的数据是以结点来表示的，每个结点的构成：元素(数据元素的映象) + 指针(指示后继元素存储位置)，元素就是存储数据的存储单元，指针就是连接每个结点的地址数据。以“结点的序列”表示的线性表称作线性链表（单链表），单链表是链式存取的结构。 对于链表的每一个结点，我们使用结构体（struct）进行设计，其主要内容有： 其中，DATA数据元素，可以为你想要储存的任何数据格式，可以是数组，可以是int，甚至可以是结构体（这就是传说中
单链表的定义
hibugs
07-06 5614
在前面的文章中，我们系统的介绍了线性表的顺序存储实现——顺序表。紧接着我们要介绍线性表的链式存储实现——链表。而链表中又有许多的链表：这一篇文章中，我们先来介绍单链表。要想知道什么是单链表，我们就可以使用我们学习过的顺序表来对比学习（对比学习有助于你的记忆，使用学习过的知识去学习未知的知识，也未尝不是一种好方法）我们都知道顺序表是申请一大块连续的区域，并且使用物理地址相邻的方法来表示逻辑上的相邻。而链表逻辑上相邻的元素在内存中可以是不相邻存放的。那么如果链表中的元素在内存中不是相邻存放的，那我们如何知道下一
【数据结构】单链表（带图详解）
Z1tai的博客
05-12 9572
概念：链表是一种物理存储结构上非连续非顺序的存储结构，但链表在逻辑上是连续的，顺序的，而数据元素的逻辑顺序是通过链表中的指针连接次序实现的。
数据结构-单链表详解
快乐的小小程序猿
09-21 6519
#include <stdio.h> #include <malloc.h> /** * 定义结点类型结构体，有一个data域和一个next域 */ typedef struct LNode { int data; struct LNode* next; }LNode, * LinkList; /** * 初始化，生成带有头结点的单链表 * @param L ...
数据结构——单链表的定义
晓风岚月
04-22 1万+
用链式存储的线性表统称为链表 链表：单链表、双链表、循环链表、静态链表 思考 单链表的定义 1.什么是单链表 2.用代码定义一个单链表 3.两种实现方式 1）.带头结点 2）.不带头结点 一、顺序表和单链表的对比 顺序表 单链表 存储方式 顺序存储 链式存储 优点 随机存储 对连续空间无要求 缺点 要求大片连续空间...
单链表的定义与基本操作.doc
09-18
单链表的定义与基本操作.doc
单链表的定义及基本操作.pdf
06-06
单链表的定义及基本操作.pdf
单链表的定义及基本操作.doc
10-08
单链表的定义及基本操作.doc
单链表的定义、表示及操作（一）
gets_s的博客
03-04 8715
一、链式存储结构的特点 用一组任意的存储单元存储线性表的数据元素（这组存储单元可以是连续的，也可以是不连续的）。因此，每个结点都必须有指针域。 二、单链表 1.定义：每一个结点只含有一个指针域的链式结构称为单链表。 2.单链表结点的类型定义： typedef struct Lnode{ int data; //数据域 struct Lnode *next; //指针域...
链表的概述，节点的定义，链表的创建，链表的遍历
yhxz1的博客
03-20 1318
链表的基础内容，创建方式，遍历方式
数据结构之单链表
容铎的博客
04-30 1172
数据结构之单链表
单链表详解（C语言版）
热门推荐
qq_44075108的博客
09-27 2万+
本文介绍单链表的定义、常用操作、优化和使用的注意点等内容。
单链表的定义和操作(超详细——C语言)
weixin_47783699的博客
10-15 2985
你还在为学习链表而烦恼？你还在为老师讲的不够简单？？你是否还在苦苦挣扎着。跟我走,我带你征服链表。
数据结构——单链表
2301_77179941的博客
05-04 3406
单链表是一种链式存取的数据结构，用一组地址任意的存储单元存放线性表中的数据元素。链表中的数据是以结点来表示的，每个结点的构成：元素(数据元素的映象) +指针(指示后继元素存储位置)，元素就是存储数据的存储单元，指针就是连接每个结点的地址数据。 ​
【java-数据结构15-模拟实现栈的方法】
最新发布
2302_80519942的博客
05-14 563
上篇文章中，我们已经手动实现了栈，下面，我们将继续手动实现栈的方法~
循环单链表c语言实现基本操作
10-08
循环单链表的基本操作包括插入、删除、查找等。 1. 插入操作: - 头插法：将新节点插入到链表头部，使其成为新的头节点。 - 尾插法：将新节点插入到链表尾部，使其成为新的尾节点。 - 按位插入：在指定位置插入新...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值