数据结构之【单链表的实现（保姆级教学）】

最新推荐文章于 2022-06-12 12:24:51 发布

cls-evd

最新推荐文章于 2022-06-12 12:24:51 发布

阅读量273

点赞数 4

分类专栏：数据结构文章标签：链表数据结构

本文链接：https://blog.csdn.net/qq_52433890/article/details/120638328

版权

数据结构专栏收录该内容

16 篇文章 2 订阅

订阅专栏

文章目录

单向无头不循环链表的实现

.无头单向非循环链表：结构简单，一般不会单独用来存数据。实际中更多是作为其他数据结构的子结构，如哈希桶、图的邻接表等等。另外这种结构在笔试面试中出现很多。

在这里插入图片描述

如上图即为链表的逻辑结构（人为想象出来的）

以下是更为具体的解释

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

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

}SLTNode;
int main()
{
	struct SListNode* node1 = (struct SListNode*)malloc(sizeof(struct SListNode));
	struct SListNode* node2 = (struct SListNode*)malloc(sizeof(struct SListNode));
	struct SListNode* node3 = (struct SListNode*)malloc(sizeof(struct SListNode));
	struct SListNode* node4 = (struct SListNode*)malloc(sizeof(struct SListNode));

	printf("%p\n", node1);
	printf("%p\n", node2);
	printf("%p\n", node3);
	printf("%p\n", node4);


}

程序运行结果如下
在这里插入图片描述
我们先用上面程序创造四个节点

一个节点就是一个结构体
链表的节点（有一个数据域和一个指针域）
指针指向下一个节点，就是他自己的类型

同时我们会发现链表是单独开空间的，地址是随机的

我们用图画来表示上述过程
这就是链表存储的物理结构
在这里插入图片描述

实际中链表的结构非常多样，以下情况组合起来就有8种链表结构：

单向、双向
带头、不带头
循环、非循环

在这里插入图片描述

1.无头单向非循环链表：结构简单，一般不会单独用来存数据。实际中更多是作为其他数据结构的子结构，如哈希桶、图的邻接表等等。另外这种结构在笔试面试中出现很多。
2.带头双向循环链表：结构最复杂，一般用在单独存储数据。实际中使用的链表数据结构，都是带头双向循环链表。另外这个结构虽然结构复杂，但是使用代码实现以后会发现结构会带来很多优势，实现反而简单了，后面我们代码实现了就知道了

在这里我们实现的是无头单向不循环的链表

接下来进入正题

打印接口的实现

假装已经有了一个链表，这里我们首先实现一下打印这个接口

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

plist是第一个节点的地址，将plist给给cur，然后将cur->next赋给cur 意思就是让cur指向下一个节点，如下是图画解释
在这里插入图片描述

尾插的实现

尾插顾名思义就是在链表的最后一个节点处再插入一个节点
我们需要考虑以下两种情况：
1.0 链表是空的
2.0 链表不是空的
但是无论是哪种我们都需要创造出一个新的节点为了使用方便，我们编写一个函数来是实现

SLTNode* BuySLTNode(SLTDataType x) //创建一个节点 
{
	SLTNode* node = (SLTNode*)malloc(sizeof(SLTNode));
	node->data = x;
	node->next = NULL;

	return node;
}

以下就是典型的错误，没考虑链表为空，发生空指针问题，程序崩溃
在这里插入图片描述
链表是空的，没有尾，如果链表不是空，链接到后面，如果链表是空，创建一个节点

改进之后的代码

void SListPushBack(SLTNode* plist, SLTDataType x)
{
	SLTNode* newnode = BuySLTNode(x);
	//分链表是空和非空两种情况
	if (plist == NULL)
	{
		plist = newnode;
	}
	else 
	{
		//先遍历找尾
		SLTNode* tail = plist;
		while (tail != NULL)
		{
			tail = tail->next;
		}
		tail->next = newnode;
	}
	
}

但是在我们改进之后发现程序仍然崩溃

下图是在尾插函数中，通过调试我们发现，在尾插函数（SListPushBack）中，newnode（创造的新节点）赋给了plist
在这里插入图片描述
但是当我们出了函数作用域后，通过调试我们发现pilst仍然为空，并没有将newnode 赋给plist

这是为什么呢？
这个地方存在着一个传值的问题
解释如下图

看到这里想必大家仍然有点有点懵逼

接下来以另一种方式解释：

假设我们要改变一个数子，采用以下代码，最终我们发现这样是改变不了的，输出结果仍然是2


#include<stdio.h>

void change(int num)
{
	int a = 5;
	num = a;
}

int main()
{
	int num=2;
	printf("%d \n",num );
	change(num);
	printf("%d \n",num );
}

在这里插入图片描述
这就类似于上述尾插，只不过在尾插当中主函数里创建的就是指针，尾插函数中传的形参也是指针，这样还是相当于传值，所以形参的改变并不会影响实参的改变。

接下来用更容易理解的方法解释：
（通过经典的交换来解释）

如果要实现交换两个数要实参需要传它们的地址，而形参就需要两个指针接收
int a, int b;
swap(&a, &b);
void swap(inta,intb);
同样，如果我们将交换数字变为交换两个指针，实参就要传指针的地址，也就是说交换函数中形参需要二级指针接受实参
int *a,int *b;
swap(&a,&b);
void swap(**a,**b)；

代码最终改进为：
ps: 对二级指针解引用就是 plist

void SListPushBack(SLTNode** pplist, SLTDataType x)
{
	SLTNode* newnode = BuySLTNode(x);
	//分链表是空和非空两种情况
	if (*pplist == NULL)
	{
		*pplist = newnode;
	}
	else 
	{
		//先遍历找尾
		SLTNode* tail = *pplist;
		while (tail->next != NULL)
		{
			tail = tail->next;
		}
		tail->next = newnode;
	}
}

总结：改变第一个节点的值传二级指针不改变第一个节点的值传一级指针

头插的实现：

第一步：需要将新节点的next指向下一个节点
第二步：plist指向newnode(同样需要二级指针)

在这里插入图片描述

void SListPushFront(SLTNode** pplist, SLTDataType x)
{
	SLTNode* newnode = BuySLTNode(x);
	newnode->next = *pplist;
	*pplist = newnode;
}

尾删的实现：

void SListPopBack(SLTNode* plist)
{
	SLTNode* tail = plist;
	while (tail->next != NULL)
	{
		tail = tail->next;
	}
	free(tail);
	tail = NULL;
}

很多人都会这样写，但这样是错的。错误之处在于没考虑1.链表是空链表， 2.没将tail前一个节点指向NULL
改进后的代码及思路如下图所示，设置一个prev

在这里插入图片描述
但是这只是理想情况
实际中还存在以下两种情况

根据分析尾删同样需要二级指针，以下是最终代码

void SListPopBack(SLTNode** pplist)
{
	//1.0  没有节点
	//2.0  1个节点
	//3.0  多个节点
	if (*pplist==NULL)
	{
		return;  //啥也不敢， 同时也可以用断言，把这种情况断死
	}
	else if ((*pplist)->next == NULL)
	{
		free(*pplist);
		*pplist = NULL;
	}
	else
	{
		SLTNode* prev = NULL;
		SLTNode* tail = *pplist;
		while (tail->next != NULL)
		{
			prev = tail;
			tail = tail->next;
		}
		free(tail);
		tail = NULL;
		prev->next = NULL;
	}
}

头删的实现

头删的实现，类比尾删的思路，同样存在三种情况：

1.0 无节点
2.0只有一个节点
3.0有多个节点

void SListPopFront(SLTNode** pplist)
{
	if (*pplist == NULL)
	{
		return;
	}
	else if ((*pplist)->next==NULL)
	{
		free(*pplist);
		*pplist = NULL;
	}
	else
	{
		SLTNode* prev = *pplist;
		*pplist = (*pplist)->next;
		free(prev);
		prev = NULL;
	}
}

单链表的查找

查找的思路就是将整个单链表遍历一次，找到你要查找的节点

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

}

注意：这里查找的函数的返回值是结构体指针类型的所以我们在调用这个接口是要用另一个指针接受
如下：

SLTNode* pos = SListFind(plist, 3);
	//if(pos!=NULL) 这样写也可行
	if (pos)
	{
		pos->data= 9;
		printf("找到了\n");
	}
	else
	{
		printf("没找到\n");
	}

单链表在pos（某个结点）位置后面插入

void SListInsertAfter(SLTNode* pos, SLTDataType x)
{
	assert(pos); //确保pos不为空
	SLTNode* newnode = BuySLTNode(x);
	newnode->next = pos->next;
	pos->next = newnode;
}

在这里插入图片描述

单链表在pos位置之前插入（很麻烦）

思路：
1. 考虑只有一个节点，只有一个节点pos，在他之前插入一个新的节点，代表着plist需要发生改变，这里就需要传二级指针(x相当于头插)
2. 有多个节点，需要找到pos前一个节点，这时候就需要遍历一遍链表

void SListInsertBefore(SLTNode** pplist, SLTNode* pos, SLTDataType x)
{
	assert(pos);
	SLTNode* newnode = BuySLTNode(x);
	if (pos == *pplist) //头插
	{
		newnode->next = pos;
		*pplist = newnode;
	}
	else
	{
		SLTNode* prev = NULL;
		SLTNode* cur = *pplist;
		while (cur != pos)
		{
			prev = cur;
			cur = cur->next;
		}
		prev->next = newnode;
		newnode->next = pos;
	}
	

}

存在多个节点的时候
思路如图所示：
在这里插入图片描述

在这里引申出一个经典的问题：在一个无头单链表的某一个节点的前面插入一个值x，应该如何插入？（不告诉你头指针）
答案是：假设某一个节点是pos，在pos后面插入一个值为x的节点，然后将后插的节点的值与pos的值交换

单链表删除pos位置之后的节点

思路：1. 考虑pos之后没有节点
2.考虑存在多个节点

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

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

}

单链表删除当前位置pos

思路：1.0 考虑pos是头结点,并且仅有头结点一个节点（当pos是头结点的时候，plist就要发生改变，所以不能传一级指针，必须要传二级指针）
2.0 考虑pos是头结点，但是后面链接有其他节点
3.0 考虑有多个节点，且pos不在头位置，需要遍历一次链表找到pos之前的节点

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

void SListEraseCur(SLTNode** pplist, SLTNode* pos)
{
	assert(pos);
	if (pos == *pplist)
	{
		SLTNode* next = pos->next;
		*pplist = next;
		free(pos);
	}
	else
	{
		SLTNode* cur = *pplist;
		SLTNode* prev = NULL;
		while (cur != pos)
		{
			prev = cur;
			cur = cur->next;
		}
		prev->next = pos->next;
		free(pos);

	}

}

到此一个单向不带头不循环的链表已经实现。
完整代码展示：
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;  
//一个节点就是一个结构体
//链表的节点（有一个数据域和一个指针域）
//指针指向下一个节点，就是他自己的类型

//单向+不带头+循环
//不改变传一级指针，要改变传二级指针
void SListPushBack(SLTNode** pplist,SLTDataType x); //plist存的就是第一个有效数据的节点
void SListPushFront(SLTNode* pplist, SLTDataType x);
void SListPopBack(SLTNode** pplist);
void SListPopFront(SLTNode** pplist);
void SListPrint(SLTNode* plist);

//单链表查找
SLTNode* SListFind(SLTNode* plist, SLTDataType x);


//单链表在pos位置后面插入
void SListInsertAfter(SLTNode* pos, SLTDataType x);

//单链表在pos位置之前插入很麻烦
void SListInsertBefore(SLTNode** pplist, SLTNode* pos, SLTDataType x);

void SListEraseAfter(SLTNode* pos);

void SListEraseCur(SLTNode** pplist, SLTNode* pos); //删除当前位置

SList.c 部分

#include "SList.h"

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

SLTNode* BuySLTNode(SLTDataType x) //创建一个节点 
{
	SLTNode* node = (SLTNode*)malloc(sizeof(SLTNode));
	node->data = x;
	node->next = NULL;

	return node;
}

void SListPushBack(SLTNode** pplist, SLTDataType x)
{
	SLTNode* newnode = BuySLTNode(x);
	//分链表是空和非空两种情况
	if (*pplist == NULL)
	{
		*pplist = newnode;
	}
	else 
	{
		//先遍历找尾
		SLTNode* tail = *pplist;
		while (tail->next != NULL)
		{
			tail = tail->next;
		}
		tail->next = newnode;
	}
}

void SListPushFront(SLTNode** pplist, SLTDataType x)
{
	SLTNode* newnode = BuySLTNode(x);
	newnode->next = *pplist;
	*pplist = newnode;
}

void SListPopBack(SLTNode** pplist)
{
	//1.0  没有节点
	//2.0  1个节点
	//3.0  多个节点
	if (*pplist==NULL)
	{
		return;  //啥也不敢， 同时也可以用断言，把这种情况断死
	}
	else if ((*pplist)->next == NULL)
	{
		free(*pplist);
		*pplist = NULL;
	}
	else
	{
		SLTNode* prev = NULL;
		SLTNode* tail = *pplist;
		while (tail->next != NULL)
		{
			prev = tail;
			tail = tail->next;
		}
		free(tail);
		tail = NULL;
		prev->next = NULL;
	}
}

void SListPopFront(SLTNode** pplist)
{
	if (*pplist == NULL)
	{
		return;
	}
	else if ((*pplist)->next==NULL)
	{
		free(*pplist);
		*pplist = NULL;
	}
	else
	{
		SLTNode* prev = *pplist;
		*pplist = (*pplist)->next;
		free(prev);
		prev = NULL;
	}
}

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

}

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


void SListInsertBefore(SLTNode** pplist, SLTNode* pos, SLTDataType x)
{
	assert(pos);
	SLTNode* newnode = BuySLTNode(x);
	if (pos == *pplist) //头插
	{
		newnode->next = pos;
		*pplist = newnode;
	}
	else
	{
		SLTNode* prev = NULL;
		SLTNode* cur = *pplist;
		while (cur != pos)
		{
			prev = cur;
			cur = cur->next;
		}
		prev->next = newnode;
		newnode->next = pos;
	}
	

}

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

		SLTNode* next = pos->next;
		pos->next = next->next;
		free(next);
	}

}

void SListEraseCur(SLTNode** pplist, SLTNode* pos)
{
	assert(pos);
	if (pos == *pplist)
	{
		SLTNode* next = pos->next;
		*pplist = next;
		free(pos);
	}
	else
	{
		SLTNode* cur = *pplist;
		SLTNode* prev = NULL;
		while (cur != pos)
		{
			prev = cur;
			cur = cur->next;
		}
		prev->next = pos->next;
		free(pos);

	}

}

test.c部分

#include"SList.h"
void TestSList1()
{
	SLTNode* plist = NULL;
	SListPushBack(&plist, 1);
	SListPushBack(&plist, 2);
	SListPushBack(&plist, 3);
	SListPushBack(&plist, 4);
	SListPrint(plist);
	SListPushFront(&plist, 0);
	SListPrint(plist);
	SListPopFront(&plist);

	SListPrint(plist);

	SListPopFront(&plist);
	
	SListPrint(plist);
}
void TestSList2()
{
	SLTNode* plist = NULL;
	SListPushBack(&plist, 1);
	SListPushBack(&plist, 2);
	SListPushBack(&plist, 3);
	SListPushBack(&plist, 4);
	SListPrint(plist);
	SLTNode* pos = SListFind(plist, 3);
	//if(pos!=NULL)
	if (pos)
	{
		pos->data= 9;
		printf("找到了\n");
	}
	else
	{
		printf("没找到\n");
	}
	SListPrint(plist);
}
void TestSList3()
{
	SLTNode* plist = NULL;
	SListPushBack(&plist, 1);
	SListPushBack(&plist, 2);
	SListPushBack(&plist, 3);
	SListPushBack(&plist, 4);
	SListPrint(plist);
	SLTNode* pos = SListFind(plist, 1);
	SListInsertAfter(pos, 30);
	SListInsertBefore(&plist,pos,3000);
	SListPrint(plist);

}

void TestSList4()
{
	SLTNode* plist = NULL;
	SListPushBack(&plist, 1);
	SListPushBack(&plist, 2);
	SListPushBack(&plist, 3);
	SListPushBack(&plist, 4);
	SListPrint(plist);
	SLTNode* pos = SListFind(plist, 3);
	SListInsertAfter(pos, 30);
	SListPrint(plist);
	SListInsertBefore(&plist, pos, 3000);
	SListPrint(plist);
	SListEraseAfter(pos);
	SListPrint(plist);
	SListEraseCur(&plist,pos);
	SListPrint(plist);

}

int main()	
{
	 TestSList4();
}

注：每个TestSList都可执行，下面是执行TestSList4（）的结果
在这里插入图片描述
感谢你们的耐心阅读！！！

cls-evd

关注

4
点赞
踩
2

收藏

觉得还不错? 一键收藏
4
评论
数据结构之【单链表的实现（保姆级教学）】

链表的实现链表的逻辑结构（人为想象出来的）以下是更为具体的解释#include<stdio.h>#include<stdlib.h>typedef int SLTDataType;typedef struct SListNode{ SLTDataType data; struct SListNode* next;}SLTNode;int main(){ struct SListNode* node1 = (struct SListNode*)mallo
复制链接

扫一扫

专栏目录