【数据结构】单链表的接口实现（附图解和源码）

已于 2023-03-20 23:54:56 修改
阅读量1.4k 收藏 9
点赞数 7
分类专栏： 初阶数据结构 文章标签： 数据结构 链表 java
于 2023-02-18 21:46:32 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2201_75587702/article/details/129102523
版权

单链表的接口实现（附图解和源码）

文章目录

前言

本文主要介绍单链表中增删查改等接口实现，结尾附总源码！

一、定义结构体

在这里插入图片描述

代码如下（示例）：

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

二、接口实现（附图解+源码）

在这里插入图片描述
这里一共11个接口，我会我都会一 一为大家讲解（图解+源码）

1.开辟新空间

(1)开辟一个链表类型的动态空间，将地址赋给指针newnode；
(2)将值放入newnode的data数据内；
(3)将新成员的next指针置为空指针，因为这个成员将成为链表的最后一个成员
注意：1.将malloc开辟空间存到newnode里面时，参数为结构体所占的字节大小！2.对newnode进行NULL判断！

代码如下（示例）：

SLTNode* BuyListNode(SLTDataType x)//开辟新空间
{
	SLTNode* newnode = (SLTNode*)malloc(sizeof(SLTNode));//开辟一个链表类型的动态空间 将地址赋给指着newnode
	if (newnode == NULL)
	{
		printf("malloc fail\n");
		exit(-1);
	}
	newnode->data = x;//将值放入newnode的data数据内
	newnode->next = NULL;//将新成员的next指针 置为空指针 因为这个成员将称为链表的最后一个成员
}

2.头插数据

注意：头插接口传参的时候一定要传二级指针变量，如果传一级指针就不会实现效果，如下图！
在这里插入图片描述

代码如下（示例）：

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

3.头删数据

头删数据注意：当单链表为空指针NULL时，头删时会对空指针进行解引用，会造成err，所以要进行两步assert断言！在这里插入图片描述

图解实现：这里传参也需要传二级指针！
在这里插入图片描述

代码如下（示例）：

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

4.打印整个单链表

注意：这里传参用一级指针即可，因为不需要对结构体进行修改访问！
在这里插入图片描述

代码如下（示例）：

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

5.尾删数据

注意：分为两种情况 1.只有一个链表；2.存在两个及以上链表！

只有一个链表 ：如下（示例）：

if ((*pphead)->next == NULL)//如果第一个链表的next指针存放的是空指针 说明只有一个链表
	{
		free(*pphead);//将唯一一个链表的动态内存释放
		*pphead = NULL;//将指针置为空指针
	}

在这里插入图片描述

两个或两个以上链表 ： 如下（示例）：
第一种情况 ： 定义两个指针情况！

//定义2个指针方法
		SLTNode* tail = *pphead;//寻找当前需要被释放的地址 所创建的变量
		SLTNode* prev = *pphead;//删除最后一个链表数据后，所保留的最后一个链表的地址。
		while (tail->next != NULL)
		{
			prev = tail;
			tail = tail->next;
		}
		//当循环停下来时 prev指针指向的是 tail前面的一个链表  而此时tail->next 指针指向的地址是NULL
		free(tail);//释放最后一个链表对应的动态内存
		tail = NULL;//将最后一个链表指针置为空指针
		prev->next = NULL;//尾删最重要的是记得要把被删除链表的前一个链表的next指针存放地址置为空指针,避免野指针的情况。

在这里插入图片描述

两个或两个以上链表 ： 如下（示例）：
第二种情况 ： 定义一个指针情况！

//定义一个指针方法
//来到这说明至少有两个链表
	SLTNode* tail = *pphead;//将链表地址交给tail指针
	while (tail->next->next)//当tail指向的地址的地址不是空指针则继续循环
	{
		tail = tail->next;//在循环中tail拿到下一个tail的next指针地址
	}
	free(tail->next);//tail指向的next地址的动态空间被释放
	tail->next = NULL;//tail指向的next指针被置为空指针

在这里插入图片描述

6.查找单链表中的数据

单链表中查找数据和顺序表里面的查找顺序非常相似，这里不做过多介绍，如果找不到返回NULL

代码如下（示例）：

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

7.在pos位置之前插入一个节点

第一种情况（pos就是*pphead）代码如下（示例）：

if (*pphead == pos)
	{
		newnode->next = *pphead;
		*pphead = newnode;
	}

在这里插入图片描述

第二种情况（pos 不是*pphead）代码如下（示例）：

else
{
	//找到pos前一个链表地址
	SLTNode* posPrev = *pphead;
	while (posPrev->next != pos)
	{
		posPrev = posPrev->next;
	}
	posPrev->next = newnode;
	newnode->next = pos;
}

在这里插入图片描述

8.在pos位置之后插入一个节点

在这里插入图片描述

代码如下（示例）：

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

9.删除pos节点

注意：这里分为两种情况：1.pos==*pphead；2.pos 不等于 * pphead

第一种情况 pos==*pphead，这里相等于头删 ：

if (*pphead == pos)
	{
		//头删
		*pphead = pos->next;
		free(pos);
	}

在这里插入图片描述

第二种情况 pos 不等于 *pphead ：

else
{
	//找前一个
	SLTNode* prev = *pphead;
	while (prev->next != pos)
	{
		prev = prev->next;
	}
	prev->next = pos->next;
	free(pos);
	pos = NULL;
}

在这里插入图片描述

10.删除pos的下一个节点

注意：如果链表为空，则不能删除，否则会对空指针进行访问！所以也需要进行两步assert断言！
在这里插入图片描述

代码如下（示例）：

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

在这里插入图片描述

11.销毁单链表

很多人都是用free直接销毁，这样会导致内存泄漏问题(因为单链表不是连续存放的），如下图所示！
在这里插入图片描述

代码如下（示例）：

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

在这里插入图片描述

三、源代码展示

1.test.c（测试+主函数）

代码如下（示例）：

#include "Slist.h"
void TestSList1()
{
	SLTNode* plist = NULL;
	SListPushBack(&plist, 1);//尾插
	SListPushBack(&plist, 2);//尾插
	SListPushBack(&plist, 3);//尾插
	SListPushBack(&plist, 4);//尾插
	SListPushFront(&plist, 5);//头插

	SListPopFront(&plist);//头删
	SListPopBack(&plist);//尾删
	SListPopBack(&plist);//尾删
	SListPopBack(&plist);//尾删
	SListPopBack(&plist);//尾删
	SListPopFront(&plist);//头删
	SListPrint(plist);//打印
}

void TestSList2()
{
	SLTNode* plist = NULL;
	SListPushBack(&plist, 1);//尾插
	SListPushBack(&plist, 2);//尾插
	SListPushBack(&plist, 1);//尾插
	SListPushBack(&plist, 3);//尾插
	SListPushBack(&plist, 4);//尾插
	SListPushBack(&plist, 1);//尾插
	SListPushFront(&plist, 5);//头插
	SListPopFront(&plist);//头删
	SListPrint(plist);//打印
}
void TestSList3()
{
	SLTNode* plist = NULL;
	SListPushBack(&plist, 1);//尾插
	SListPushBack(&plist, 2);//尾插
	SListPushBack(&plist, 1);//尾插
	SListPushBack(&plist, 3);//尾插
	SListPushBack(&plist, 4);//尾插
	SListPushBack(&plist, 1);//尾插
	SListPushFront(&plist, 5);//头插

	SLTNode* pos = SListFind(plist, 1);
	int i = 1;
	while (pos)
	{
		printf("第%d个pos节点:%p->%d\n", i++, pos, pos->data);
		pos = SListFind(pos->next, 1);
	}

	pos = SListFind(plist, 4);
	if (pos)
	{
		pos->data = 30;
	}
	SListPrint(plist);
}


void TestSList4()
{
	SLTNode* plist = NULL;
	SListPushBack(&plist, 2);//尾插
	SListPushBack(&plist, 3);//尾插
	SListPushBack(&plist, 4);//尾插
	SListPushBack(&plist, 5);//尾插
	SListPushBack(&plist, 6);//尾插
	SListPushFront(&plist, 1);//头插
	//SLTNode* pos = SListFind(plist, 6);
	//SListInserAfter(pos, 1);
	//SListInsert(&plist, pos, 7);
	//SListErase(&plist, pos);
	SListDestroy(&plist);
	SListPrint(plist);
}
int main()
{
	//TestSList1();
	//TestSList2();
	//TestSList3();
	TestSList4();
	return 0;
}

2.Slist.h（接口函数的声明）

代码如下（示例）：

#pragma onc
#include <stdio.h>
#include <stdlib.h>
#include <assert.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);//头删
SLTNode* SListFind(SLTNode* phead, SLTDataType x);//找数据
//在pos位置前插入一个节点
void SListInsert(SLTNode** pphead, SLTNode* pos, SLTDataType x);
//在pos位置之后去插入一个节点
void SListInserAfter(SLTNode* pos, SLTDataType x);
void SListErase(SLTNode** pphead, SLTNode* pos);//删除pos节点
void SListEraseAfter(SLTNode* pos);//删除pos的下一个节点
void SListDestroy(SLTNode** pphead);

3.Slist.c（接口函数的实现）

代码如下（示例）：

#include "Slist.h"
SLTNode* BuyListNode(SLTDataType x)//开辟新空间
{
	SLTNode* newnode = (SLTNode*)malloc(sizeof(SLTNode));//开辟一个链表类型的动态空间 将地址赋给指着newnode
	if (newnode == NULL)
	{
		printf("malloc fail\n");
		exit(-1);
	}
	newnode->data = x;//将值放入newnode的data数据内
	newnode->next = NULL;//将新成员的next指针 置为空指针 因为这个成员将称为链表的最后一个成员
}
void SListPrint(SLTNode* phead)
{
	SLTNode* cur = phead;
	while (cur != NULL)
	{
		printf("%d->", cur->data);
		cur = cur->next;
	}
	printf("NULL\n");
}
void SListPushBack(SLTNode** pphead, SLTDataType x)
{
	assert(pphead);
	SLTNode* newnode = BuyListNode(x);
	if (*pphead == NULL)
	{
		*pphead = newnode;//如果*pphead是空指针 将 newnode的地址给与 *pphead 称为链表的第一个成员
	}
	else
	{
		//如果链表已经不是空的了 *pphead那么肯定也不是NULL空指针则进入这里
		SLTNode* tail = *pphead;//用一个tail指针 接收链表地址
		while (tail->next != NULL)//while寻找链表的最后成员
		{
			tail = tail->next;//循环直至找到最后一个链表的成员
		}
		tail->next = newnode;//最后一个成员取得新链表成员地址
	}
}
void SListPushFront(SLTNode** pphead, SLTDataType x)
{
	assert(pphead);
	SLTNode* newnode = BuyListNode(x);
	newnode->next = *pphead;
	*pphead = newnode;
}
void SListPopBack(SLTNode** pphead)
{
	assert(pphead);
	assert(*pphead != NULL);//仿C++处理错误的方式
	//来到这说明至少有一个链表  或 两个以上链表
	if ((*pphead)->next == NULL)//如果第一个链表的next指针存放的是空指针 说明只有一个链表
	{
		free(*pphead);//将唯一一个链表的动态内存释放
		*pphead = NULL;//将指针置为空指针
	}
	else
	{
		//定义2个指针方法
		SLTNode* tail = *pphead;//寻找当前需要被释放的地址 所创建的变量
		SLTNode* prev = *pphead;//删除最后一个链表数据后，所保留的最后一个链表的地址。
		while (tail->next != NULL)
		{
			prev = tail;
			tail = tail->next;
		}
		//当循环停下来时 prev指针指向的是 tail前面的一个链表  而此时tail->next 指针指向的地址是NULL
		free(tail);//释放最后一个链表对应的动态内存
		tail = NULL;//将最后一个链表指针置为空指针
		prev->next = NULL;//尾删最重要的是记得要把被删除链表的前一个链表的next指针存放地址置为空指针,避免野指针的情况。

		//定义一个指针方法
		//来到这说明至少有两个链表
		//SLTNode* tail = *pphead;//将链表地址交给tail指针
		//while (tail->next->next)//当tail指向的地址的地址不是空指针则继续循环
		//{
		//	tail = tail->next;//在循环中tail拿到下一个tail的next指针地址
		//}
		//free(tail->next);//tail指向的next地址的动态空间被释放
		//tail->next = NULL;//tail指向的next指针被置为空指针
	}
}
void SListPopFront(SLTNode** pphead)
{
	assert(pphead);
	assert(*pphead != NULL);
	SLTNode* next = (*pphead)->next;
	free(*pphead);
	*pphead = next;
}
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);
	SLTNode* newnode = BuyListNode(x);
	if (*pphead == pos)
	{
		newnode->next = *pphead;
		*pphead = newnode;
	}
	else
	{
		//找到pos前一个链表地址
		SLTNode* posPrev = *pphead;
		while (posPrev->next != pos)
		{
			posPrev = posPrev->next;
		}
		posPrev->next = newnode;
		newnode->next = pos;
	}
}
//自己写的
void SListInserAfter(SLTNode* pos, SLTDataType x)
{
	assert(pos);
	SLTNode* newnode = BuyListNode(x);
	newnode->next = pos->next;
	pos->next = newnode;
}
void SListErase(SLTNode** pphead, SLTNode* pos)
{
	assert(pos);
	if (*pphead == pos)
	{
		//头删
		*pphead = pos->next;
		free(pos);
	}
	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 SListDestroy(SLTNode** pphead)
{
	assert(pphead);
	while (*pphead)
	{
		SLTNode* tmp = (*pphead)->next;
		free(*pphead);
		*pphead = tmp;
	}
	*pphead = NULL;
}

总结

以上就是今天要讲的内容，本文介绍了单链表11种接口的模拟实现的图解+源代码
如果我的博客对你有所帮助记得三连支持一下，感谢大家的支持！

在这里插入图片描述

铭哥的编程日记
关注
  • 7
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 5
    评论
专栏目录
DS--链表的概念及单链表接口的实现及其应用
烟华的博客
07-24 321
链表 概念：链表是一种物理存储结构上非连续，非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接此项实现的。 链表的结构类型可分为： 1，单链表，双向链表 2，不带头单链表，带头链表 3，单链表，循环单链表 链表的实现 一，单链表接口的实现 声明文件SList.h SList.h #ifndef _SLIST_H_ #define _SLIST_H_ #include<Window...
单链表各个接口的实现
yam_sunshine的博客
12-06 405
注意单链表的方向不能逆转 //接口声明 #define _CRT_SECURE_NO_WARNINGS 1 #define _CRT_SECURE_NO_WARNINGS 1 #ifndef Seqlist_H #define Seqlist_H #include &lt;stdio.h&gt; #include &lt;stdlib.h&gt; #include &lt;malloc.h&gt;...
简单的单链表 接口
qq_18607263的博客
10-21 127
链表具有头部节点，省的总处理头节点麻烦 提出api typedef void CALLBACK onDataCbk(int Id, char* data); typedef struct linklist { char* data; struct linklist* next; }list, * plist; extern plist create_list(); extern void print_list(plist head, onDataCbk Cbk); extern b
[数据结构] 链表接口实现
giturtle's blog
03-04 326
链表定义 定义 链表是一种物理存储结构上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的 。
单链表的基本接口
Hello World！
07-19 663
SList.h #ifndef _SLIST_H_ #define _SLIST_H_ #include<stdio.h> #include<windows.h> typedef int SLTDataType; typedef struct SListNode { SLTDataType data; struct SListNode* next; }SList...
图解数据结构C++版源码
01-13
本次上传的是图解数据结构 使用C++这本书的配套源码，代码无错误
图解几种常用数据结构（PPT）
03-20
在本文中，我们将图解几种常用的数据结构，包括单链表、栈、队列、Trie树和并查集。 1. 单链表 单链表是一种基本的数据结构，由一系列节点组成，每个节点包含一个数据元素和一个指向下一个节点的指针。单链表的...
图解数据结构 使用C++
09-29
图解数据结构 使用C++；
《图解算法数据结构》~ 数据结构笔记
11-15
本文主要记录了学习《图解算法数据结构》一书中“数据结构”章节所做练习题的笔记，记录其中的思路以及碰到的问题等。因为学习的这本书是在`leetcode`上的，但是感觉`leetcode`上只要求做函数本身的实现，而无法做到...
单链表接口的实现
TANGY的博客
01-03 198
SList.h #ifndef __TEST_H__ #define __TEST_H__ #include&lt;stdio.h&gt; #include&lt;assert.h&gt; #include&lt;stdlib.h&gt; #include&lt;malloc.h&gt; typedef int SLTDataType; typedef struct SListNode { S...
单链表源码 实现各种单链表功能
04-23
实现获得单链表中第i个元素的方法； 实现在第i个位置之前插入元素的方法； 逆位序输入n个元素的值，建立带表头节点的单链表L; 删除在第i(不包括头节点)个位置之前的那个元素的方法； 实现获得单链表中第i个元素的方法； 实现在第i个位置之前插入元素的方法； 删除在第i个位置之前的那个元素的方法的实现部分
单链表的实现与常见接口的详细图解剖析
程序猿教你打篮球的博客
03-08 1522
单链表的常见接口详细讲解，深度解剖，不仅有好的代码风格，还有精美的配图，给你带来直观的感受！
数据结构--顺序表与链表的区别
qq_35297945的博客
01-10 1189
1 顺序表 顺序表是用一段物理地址连续的存储单元依次存储数据元素的线性结构，一般情况下采用数组存储，在数组上完成数据的增删查改。   优点： （1）存储空间连续; （2）支持随机访问； （3）空间利用率高，不容易造成内存碎片； （4）尾插尾删操作效率高。   缺点： （1）在中间或者前面插入数据时的时间复杂度为O(n)； （2）存储空间的容量可能不够用，可能存在增容的问题，而增容的代价很高。 2 链表 链表是一种物理存储结构上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。  
单链表基础接口实现
Emperor10的博客
04-29 307
链表概念 链表是一种物理存储单元上非连续的存储结构。 接口实现 以 非循环，不带头结点的单链表为例 1. 抽象链表类 class ListNode { public int val;//值 public ListNode next;//存储下一个节点的地址 也就是说 这个是一个引用 public ListNode() { } public ListNode(int val) { this.val = val; } } 1.
数据结构：实现单链表的各个接口
ETalien_的博客
11-06 300
实现单链表的各个接口 SList.h #pragma once #include &amp;amp;amp;amp;amp;amp;amp;lt;stdlib.h&amp;amp;amp;amp;amp;amp;amp;gt; #include &amp;amp;amp;amp;amp;amp;amp;lt;stdio.h&amp;amp;amp;amp;amp;amp;amp;gt; #include &amp;amp;amp;amp;amp;amp;
链表---双向带头循环链表及其多种接口的实现（完美结构）
KLZUQ的博客
11-17 206
以上就是我们完成的所有接口，大家自己试一下会发现，这个链表的结构非常完美，它的插入和删除的时间复杂度都是o(1)，只有查找我们是用的是正常方法，时间复杂度为o(n)。今天我们继续来完成链表，但是今天我们来实现双向带头循环链表，这与我们之前写的单项不带头非循环链表相对应，链表一共可以有8种形式，学会了这两种，其他6种也都游刃有余。我们看到，当链表为空时它仍然不会出现错误，这个结构是最优的，我在结尾会告诉大家这个链表的真正优点，接下来就不再啰嗦。有了尾插，我们接着来实现打印，方便我们观察和调试。
【数据结构】双向链表的接口实现（附图解和源码）
铭哥不写bug的博客
02-25 861
本文介绍双向链表的接口实现（附图解和源码），如果我的博客对你有所帮助记得三连支持一下，感谢大家的支持！
链表的几个接口实现
ChaserZHY的博客
11-21 380
在这篇博客介绍一下数据结构线性表链表的几个接口实现，话不多说，进入正题。 头插法 头插法是链表的几大接口之一，在进入头插时也得考虑有没有节点让你头插，如果没有就创造一个节点。所以先给出一个创造节点的函数： SListNode* BuySListNode(SLDataType x)//创造一个新的节点 { SListNode *Node = (SListNode*)melloc(sizeof(SL...
【单向链表】的一些接口_C语言实现
YellowOPea的博客
10-31 231
分析单向链表，并用C语言实现单向链表的一些接口
翼边数据结构与半边数据结构图解
最新发布
04-02
翼边数据结构（Winged Edge）和半边数据结构（Half-Edge）是两种常用于表示多边形网格的数据结构。它们可以用于描述三维模型的拓扑结构和几何信息。 1. 翼边数据结构： 翼边数据结构是一种基于边的数据结构，它将每...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值