单链表（增删查改）

原创 已于 2023-03-07 16:41:17 修改 · 1.2k 阅读 · 4 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#链表 #数据结构 #c语言

于 2023-03-07 16:38:20 首次发布
本文介绍了单链表的基本概念，包括其数据结构和操作方法，如头插、尾插、头删、尾删、查找、插入和删除等。提供了完整的C语言实现代码，包括结构体定义、节点操作函数以及测试用例，展示了如何在实际编程中对单链表进行操作。

目录

一、什么是单链表？

单链表是一种链式存取的数据结构，，链表中的数据是以结点来表示的，每个结点的构成：元素(数据元素的映象) + 指针(指示后继元素存储位置)，元素就是存储数据的存储单元，指针就是连接每个结点的地址数据。以“结点的序列”表示的线性表称作线性链表（单链表），单链表是链式存取的结构。简单来说单链表就是一个一个的节点链接起来的链式结构，每个节点里面存储着一个数据和与它链接的下一个节点的（指针）地址。（注意，每一个节点都是同一种结构体类型）

二、单链表的增删查改

2.1 结构体变量的声明

typedef int SLTDataType;
typedef struct SLTNode
{
	SLTDataType data;
	struct SLTNode* next;

}SLTNode;

2.2 申请新结点

SLTNode* BuySListNode(SLTDataType x)
{
	SLTNode* newNode = (SLTNode*)malloc(sizeof(SLTNode));
	if (newNode == NULL)
	{
		perror("malloc fail");
		return NULL;
	}
	else
	{
		newNode->data = x;
		newNode->next = NULL;
		return newNode;
	}
}

2.2 链表的头插

void SListPushFront(SLTNode** pphead, SLTDataType x)
{
	assert(pphead);
	SLTNode* newNode = BuySListNode(x);
	newNode->next = *pphead;
	*pphead = newNode;
}

2.3 链表的尾插

void SListPushBack(SLTNode** pphead, SLTDataType x)
{
	assert(pphead);
	SLTNode* newNode = BuySListNode(x);
	if (*pphead == NULL)
	{
		*pphead = newNode;
	}
	else
	{
		SLTNode* tail = *pphead;
		while (tail->next)
		{
			tail = tail->next;
		}
		tail->next = newNode;
	}

}

2.4 链表的头删

void SListPopFront(SLTNode** pphead)
{
	assert(pphead && *pphead);
	SLTNode* del = *pphead;
	*pphead = (*pphead)->next;
	free(del);
	del = NULL;

}

2.5 链表的尾删

void SListPopBack(SLTNode** pphead)
{
	assert(pphead);
	assert(*pphead);
	if ((*pphead)->next == NULL)
	{
		free(*pphead);
		*pphead = NULL;
	}
	else
	{
		SLTNode* tailPrev = NULL;
		SLTNode* tail = *pphead;
		while (tail->next)
		{
			tailPrev = tail;
			tail = tail->next;
		}
		tailPrev->next = NULL;
		free(tail);
		tail = NULL;


	}

}

2.6 链表的查找

SLTNode* SListFind(SLTNode* pphead, SLTDataType x)
{
	SLTNode* cur = pphead;
	while (cur)
	{
		if (cur->data == x)
		{
			return cur;
		}
		else
		{
			cur = cur->next;
		}
	}
	printf("找不到%d\n",x);
	return NULL;

}

2.7 链表的任意位置后面插入

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


}

2.8 链表的任意位置后面删除

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


}

2.9 链表的销毁

//建议传二级指针，因为销毁的话需要把这个指向链表的指针置空
//传一级指针无法把指向链表的指针置空
void SListDestroy(SLTNode** pphead)
{
	SLTNode* cur = *pphead;
	while (cur)
	{
		SLTNode* del = cur;
		cur = cur->next;
		free(del);
		del = NULL;
	}
	*pphead = NULL;
}

2.10 链表的打印

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

}

三、代码汇总

3.1 SLish.h

#pragma once

//SList.h

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

typedef int SLTDataType;
typedef struct SLTNode
{
	SLTDataType data;
	struct SLTNode* next;

}SLTNode;

// 动态申请一个节点
extern SLTNode* BuySListNode(SLTDataType x);
// 单链表打印
extern void SListPrint(SLTNode* phead);
// 单链表尾插
extern void SListPushBack(SLTNode** pphead, SLTDataType x);
// 单链表的头插
extern void SListPushFront(SLTNode** pphead, SLTDataType x);
// 单链表的尾删
extern void SListPopBack(SLTNode** pphead);
// 单链表头删
extern void SListPopFront(SLTNode** pphead);
// 单链表查找
extern SLTNode* SListFind(SLTNode* pphead, SLTDataType x);
// 单链表在pos位置之后插入x
// 分析思考为什么不在pos位置之前插入？
extern void SListInsertAfter(SLTNode* pos, SLTDataType x);
// 单链表删除pos位置之后的值
// 分析思考为什么不删除pos位置？
extern void SListEraseAfter(SLTNode* pos);
// 单链表的销毁
extern void SListDestroy(SLTNode** pphead);

3.2 SLish.c

#define _CRT_SECURE_NO_WARNINGS 1

////////////////////////////////////////////
//Slist.c

#include "SList.h"

SLTNode* BuySListNode(SLTDataType x)
{
	SLTNode* newNode = (SLTNode*)malloc(sizeof(SLTNode));
	if (newNode == NULL)
	{
		perror("malloc fail");
		return NULL;
	}
	else
	{
		newNode->data = x;
		newNode->next = NULL;
		return newNode;
	}
}

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

}


void SListPushBack(SLTNode** pphead, SLTDataType x)
{
	assert(pphead);
	SLTNode* newNode = BuySListNode(x);
	if (*pphead == NULL)
	{
		*pphead = newNode;
	}
	else
	{
		SLTNode* tail = *pphead;
		while (tail->next)
		{
			tail = tail->next;
		}
		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)
	{
		free(*pphead);
		*pphead = NULL;
	}
	else
	{
		SLTNode* tailPrev = NULL;
		SLTNode* tail = *pphead;
		while (tail->next)
		{
			tailPrev = tail;
			tail = tail->next;
		}
		tailPrev->next = NULL;
		free(tail);
		tail = NULL;


	}

}


void SListPopFront(SLTNode** pphead)
{
	assert(pphead && *pphead);
	SLTNode* del = *pphead;
	*pphead = (*pphead)->next;
	free(del);
	del = NULL;

}

SLTNode* SListFind(SLTNode* pphead, SLTDataType x)
{
	SLTNode* cur = pphead;
	while (cur)
	{
		if (cur->data == x)
		{
			return cur;
		}
		else
		{
			cur = cur->next;
		}
	}
	printf("找不到%d\n",x);
	return NULL;

}

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


}

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


}


void SListDestroy(SLTNode** pphead)
{
	SLTNode* cur = *pphead;
	while (cur)
	{
		SLTNode* del = cur;
		cur = cur->next;
		free(del);
		del = NULL;
	}
	*pphead = NULL;
}

3.3 test.c

#define _CRT_SECURE_NO_WARNINGS 1

////////////////////////////////////////////
//test.c

#include "SList.h"

void test_SListPushBack(void)
{
	SLTNode* plist = NULL;
	SListPushBack(&plist, 1);
	SListPushBack(&plist, 2);
	SListPushBack(&plist, 3);
	SListPushBack(&plist, 4);
	SListPushBack(&plist, 5);
	SListPrint(plist);

	SLTNode* ret = SListFind(plist, 1);
	if (ret != NULL)
	{
		printf("找到了，地址为：%p\n", ret);
		SListInsertAfter(ret, 6);
		SListPrint(plist);
	}


	ret = SListFind(plist, 1);
	if (ret != NULL)
	{
		printf("找到了，地址为：%p\n", ret);
		SListInsertAfter(ret, 7);
		SListPrint(plist);
	}

	ret = SListFind(plist, 1);
	if (ret != NULL)
	{
		printf("找到了，地址为：%p\n", ret);
		SListInsertAfter(ret, 8);
		SListPrint(plist);
	}

	ret = SListFind(plist, 1);
	if (ret != NULL)
	{
		printf("找到了，地址为：%p\n", ret);
		SListInsertAfter(ret, 9);
		SListPrint(plist);
	}

	ret = SListFind(plist, 1);
	if (ret != NULL)
	{
		printf("找到了，地址为：%p\n", ret);
		SListInsertAfter(ret, 10);
		SListPrint(plist);
	}

	/*SLTNode* ret = SListFind(plist, 1);
	if (ret != NULL)
	{
		printf("找到了，地址为：%p\n", ret);
		SListEraseAfter(ret);
		SListPrint(plist);
	}
	

	ret = SListFind(plist, 1);
	if (ret != NULL)
	{
		printf("找到了，地址为：%p\n", ret);
		SListEraseAfter(ret);
		SListPrint(plist);
	}

	ret = SListFind(plist, 1);
	if (ret != NULL)
	{
		printf("找到了，地址为：%p\n", ret);
		SListEraseAfter(ret);
		SListPrint(plist);
	}

	ret = SListFind(plist, 1);
	if (ret != NULL)
	{
		printf("找到了，地址为：%p\n", ret);
		SListEraseAfter(ret);
		SListPrint(plist);
	}*/

	/*ret = SListFind(plist, 1);
	if (ret != NULL)
	{
		printf("找到了，地址为：%p\n", ret);
		SListEraseAfter(ret);
		SListPrint(plist);
	}*/
	

	//SListInsertAfter(ret, 8);
	/*SListPrint(plist);

	SListPopFront(&plist);
	SListPrint(plist);

	SListPopFront(&plist);
	SListPrint(plist); 

	SListPopFront(&plist);
	SListPrint(plist); 

	SListPopFront(&plist);
	SListPrint(plist); 

	SListPopFront(&plist);
	SListPrint(plist);*/

}

void test_SListPushFront(void)
{
	SLTNode* plist = NULL;
	SListPushFront(&plist, 1);
	SListPushFront(&plist, 2);
	SListPushFront(&plist, 3);
	SListPushFront(&plist, 4);
	SListPushFront(&plist, 5);
	SListPrint(plist);

	SListPopFront(&plist);
	SListPrint(plist);

	SListPopFront(&plist);
	SListPrint(plist);

	SListPopFront(&plist);
	SListPrint(plist);

	SListPopFront(&plist);
	SListPrint(plist);

	SListPopFront(&plist);
	SListPrint(plist);

	/*SListPopFront(&plist);
	SListPrint(plist);*/



	//SListDestroy(plist);
	//SListPrint(plist);

	/*SListPopBack(&plist);
	SListPrint(plist);

	SListPopBack(&plist);
	SListPrint(plist);
	
	SListPopBack(&plist);
	SListPrint(plist);
	
	SListPopBack(&plist);
	SListPrint(plist);
	
	SListPopBack(&plist);
	SListPrint(plist);*/

}


int main()
{
	
	//test_SListPushBack();
	test_SListPushFront();

	return 0;
}

以上就是有关单链表增删查改的全部内容了，你学会了吗？如果对你有帮助，点亮一下小心心，点点关注呗，后期会持续更新计算机相关知识哦！！！

基于Java实现单链表的增删改查
cly_32的博客
04-07 1216
基于Java实现单链表的增删改查一、新建学生节点类二、新建一个操作链表的类，实现增删改查方法三、新建操作链表类的实现类实现其增删改查功能 一、新建学生节点类 Stu_Node节点包含： 学号：int num; 姓名：String name; 性别：String gender; 下一个节点：Stu_Node next; 为了便于打印节点内容需要重写toString方法 class Stu_Node{ int num; String name; String gender;
数据结构之带头节点的单链表增删改查操作实现
weixin_62579654的博客
07-17 1357
数据结构之带头节点的单链表增删改查操作实现
单链表c语言实现增删改查操作
09-21
VS2008运行环境 c语言实现单链表增删改查操作 并输出到控制台上
【数据结构】—— 单链表的增删改查
周小末天天开心的博客
11-22 1993
单链表的创建、删除、更改、查看
单链表的增删改查
程序猿阿蛮
07-09 269
除了尾部添加的方式，其他的增删改都需要找到前一个节点进行操作。 在有头结点的链表中，头节点不能改变。 // 定义一个链表管理节点 class SingleLinkedList { private Node headNode = new Node(0,"head"); // 1、尾部添加 public void add(Node node){ // 由于不能修改头节点，创建临时节点 Node temp = headNode; w.
单链表增删查改图解思路＋详细代码（C语言）
weixin_59042805的博客
05-07 1578
目录前言一、单链表的初始化和打印二、增删查改1.尾插头插2.尾删头删3.指定位置的增删总结 前言 今天是我加入csdn的第336天，当然要写一篇博客记录一下~ 想起最开始注册博客是为了复制代码完成学校作业，后来搁置了大半年，最近4,5个月才使用频繁一点。准备坚持多写一点也算巩固自身！✨✨✨ 言归正传，我们说单链表。 链表是一种链式存取的数据结构，通过指针将一个个零散的内存块连接起来，用一组地址任意的存储单元存放线性表中的数据元素。每个结点只有一个链域的链表称为单链表。 一、单链表的初始化和打印 这里要
单链表增删查改代码（详细注释）
nainaire的博客
01-28 662
代码，数据结构的单链表基础功能函数，头文件，测试文件
Java单链表增删查改及就地逆置实现
标签“单链表带头节点 Java单链表 就地逆置 增删改查，倒数第k个节点”则强调了该文件内容的重点是带有头节点的单链表实现，展示了在Java语言环境下如何不借助辅助工具实现链表的相关功能。接下来，我们将详细说明...
单链表增删查改代码c++实现
最新发布
07-03
在单链表中增加节点通常涉及到创建一个新的节点，并将其链接到现有的链表中。下面是C++实现的示例代码，演示了如何在单链表的末尾添加一个新节点： ```cpp struct LNode { int data; // 节点存储的数据 LNode* ...
C语言数据结构单链表的增删查改
04-29
C语言数据结构单链表的增删查改
Java数据结构之链表（Linked List）
weixin_30627341的博客
07-24 308
1.链表(Linked List)介绍 链表是有序的列表，但是它在内存存储结构如下： 2.特点： 链表是以节点的方式来存储,是链式存储 每个节点包含 data 域， next 域：指向下一个节点. 链表的各个节点不一定是连续存储. 链表分带头节点的链表和没有头节点的链表，根据实际的需求来确定 3.单链表介绍 单链表(带头结点) 逻辑结构示意图如下： 4....
单链表的增删查改
weixin_33946020的博客
04-25 126
1 /* 2 寻常的函数实现 3 并非类定义 4 */ 5 6 #include<iostream> 7 #include<bits/stdc++.h> 8 using namespace std; 9 struct Node{ 10 int value; 11 Node * next; 12 }; 13 vo...
单链表（增删改查）
kepp_smiling的博客
08-10 455
#include<stdio.h> #include<stdlib.h> #include<stdbool.h> #define DataType int struct node { DataType data; struct node* next; }; typedef struct node* pnode; void head_insert(pnode*,DataType);//
单链表的增删查改(数据结构)
Marksky的博客
05-24 343
单链表的增删查改（数据结构）
【单链表】单链表的增删改查
热爱编程的菜鸟
11-01 728
链表（Linked List) 链表是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。链表由一系列结点（链表中每一个元素称为结点）组成，结点可以在运行时动态生成。每个结点包括两个部分：一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域。 单链表(single LinkedList） 单链表是一种链式存取的数据结构，用一组地址任意的存储单元存放线性表中的数据元素。链表中的数据是以结点来表示的，每个结点的构成：元素(数据元素的映象) + 指针(指示后继
评论 4
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值