初阶数据结构之单链表的实现（四）

---

---

链表的概念及结构

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

---

一、链表的逻辑结构是什么样的？

所谓的逻辑结构其实就是能让我们自己能够更好的理解这个东西是什么？那么我们就用画图来理解理解吧！！在单链表中，存放着两个量，一个是地址量，一个是数据量，如图所示，这是一个带头的单链表。

二、链表的初始化

2.1链表初始化的示意

正如上图所说，单链表中存在一个数据量和一个地址量，所以我们定义结构体的时候，应该定一个data数据量，和一个指针用来存放自己所以定义的地址量。

2.2链表初始化代码实现

代码如下：

typedef int SLTDataType;

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

并且还需要定义几个头文件如下所示

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

这里介绍一个查询头文件的网站CPlusplus

---

三、链表的各类接口函数定义

void SLTPrint(SLTNode* phead);
void SLTPushBack(SLTNode** pphead, SLTDataType x);
void SLTPushFront(SLTNode** pphead, SLTDataType x);

void SLTPopBack(SLTNode** pphead);
void SLTPopFront(SLTNode** pphead);

SLTNode* SLTFind(SLTNode* phead, SLTDataType x);

//在pos之前插入
void SLInsert(SLTNode** pphead,SLTNode* pos, SLTDataType x);
void SLInsertAfter(SLTNode* pos, SLTDataType x);
//删除pos位置的值
void SLErase(SLTNode** pphead, SLTNode* pos);
void SLEraseAfter(SLTNode* pos);

void SLTDestroy(SLTNode* phead);

四、链表的各类接口函数的代码实现

4.1链表的打印代码实现

因为我们写的是带头的单链表，所以我们就可以从头开始遍历。我们定义一个结构体指针用来存放头结点，因为头结点此时存放的是下一个位置的地址，所以我们只需要拿一个指针去接收它就行啦。

那我们此时该思考一下，我们虽然是通过遍历来打印数据，但是我们是不是得想一下结束条件呢？如果我们用cur->next == NULL 作为结束条件，那么我们是不是想错了呢？我们画图解释一下吧！从图中看，如果我们以cur->next为结束条件那么，最后一个数我们是不是就打印不了，所以我们就想错啦

我们在来看看下图，我们发现用cur本身去遍历就可以把全部都遍历完，好啦这里我们算是解释通啦！

4.1.1打印代码的实现

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

4.2链表的尾插代码实现

尾插顾名思义就是在尾部进行插入，那么我们应该怎么样去实现单链表的尾部插入呢？我们还是画图进行理解,如下图所示。

我们想要在尾部进行插入，我们是不是应该先遍历到尾结点呢？是的没错！但是这里我们就得注意我们遍历结束的条件了，为什么这么说呢？假设如果按照我们上面打印那样遍历的话，我们就会遍历成野指针，所以我们遍历的条件为cur->next ，这样是不是就解决啦！

这里我们得考虑两种情况。
1、当这个链表是空的时候我们应该怎么去处理他呢？我们直接让新建立的节点赋值给我们的头就行啦
2、也就是正常的插入啦！让最后一个节点的指针指向新节点，然后再把最后一个节点的位置改变就完成啦！

4.2.1尾插代码实现

void SLTPushBack(SLTNode** pphead, SLTDataType x)
{
    
    
	assert(pphead);
	SLTNode* newnode = BuyLTNode(x);
	if ((*pphead) == NULL)
	{
    
    
		*pphead = newnode;
	}
	else
	{
    
    
		SLTNode* tail = *pphead;
		while (tail->next)
		{
    
    
			tail = tail->next;
		}
		tail->next = newnode;
	}
}

4.3链表的头插代码实现

关于头插我们应该这样处理：
1、因为我们是带有头结点的单链表，又因为我们头结点存储的是第一个节点的地址，所以只需要把头结点所存储的地址赋给新开的节点的next位置，此时的新节点所指向的就是原来第一个节点的位置
2、因为头结点存储第一个节点的地址，所以我们要把新开的节点的地址赋给头结点，这样就完成了头插！

1图文解释：插入前：

2、插入中：

3、结束插入：

4.3.1头插代码的实现

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

4.4BuyLTNode函数的实现

本函数的意思是动态的开辟一个节点在堆上！

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

4.5链表的尾删代码实现

在单链表中，尾删的效率其实是非常的差的，因为单链表需要一直遍历查找，所以效率耗费的十分的严重。

在尾删的过程中，我们也需要考虑两种情况！
第一种情况：当链表中只有一个节点的时候我们应该怎么样的删除
第二种情况：当链表中有多个节点的时候我们应该怎么删除呢？

当只有一个节点的时候，我们应该直接把节点free掉，因为我们的节点都是动态开辟的，所以我们应用free这个函数，把节点摧毁掉

当有多个节点的时候，我们应该用两个指针，一个在前面一个在后面，当前面的节点为空时，说明我们找到了尾，我们free掉尾结点就行啦！

4.5.1尾删代码的实现

void SLTPopBack(SLTNode** pphead)
{
    
    
	//当只有一个节点的时候
	//多个节点
	assert(pphead);
	assert(*pphead);
	if ((*pphead)->next == NULL)
	{
    
    
		free(*pphead);
		*pphead = NULL;
	}
	else
	{
    
    
		SLTNode* tail = *pphead;
		SLTNode* prev = NULL;
		while (tail->next)
		{
    
    
			prev = tail;
			tail = tail->next;
		}
		free(tail);
		prev->next = NULL;
	}
}

4.6链表的头删代码实现

如下图所示，先让pphead往前先走一步，提前找好一个前节点，然后free掉他，然后把pphead赋值给prev，再让*pphead往前走！

4.6.1头插代码的实现

void SLTPopFront(SLTNode** pphead)
{
    
    
	//空链表
	assert(*pphead);
	assert(pphead);
	SLTNode* prev = *pphead;
	*pphead = prev->next;
	free(prev);
}

五、完整代码的实现

test.c

#define _CRT_SECURE_NO_WARNINGS 1
#include"listnode.h"

void test1()
{
    
    
	SLTNode* plist = NULL;
	SLTPushFront(&plist, 0);
	SLTPushFront(&plist, 1);
	SLTPushFront(&plist, 2);
	SLTPushFront(&plist, 3);
	SLTPrint(plist);
	SLTPushBack(&plist, -1);
	SLTPrint(plist);
}
void test2()
{
    
    
	SLTNode* plist = NULL;
	SLTPushBack(&plist, -1);
	SLTPushBack(&plist, 0);
	SLTPushBack(&plist, 1);
	SLTPrint(plist);
	SLTPopBack(&plist);
	SLTPopBack(&plist);
	SLTPopBack(&plist);
	SLTPrint(plist);
}
void test3()
{
    
    
	SLTNode* plist = NULL;
	SLTPushBack(&plist, -1);
	SLTPushBack(&plist, 0);
	SLTPushBack(&plist, 1);
	SLTPrint(plist);
	SLTPopFront(&plist);
	SLTPopFront(&plist);
	SLTPopFront(&plist);
	SLTPrint(plist);
}
void test4()
{
    
    
	SLTNode* plist = NULL;
	SLTPushBack(&plist, 1);
	SLTPushBack(&plist, 2);
	SLTPushBack(&plist, 3);
	SLTPushBack(&plist, 4);
	SLTPrint(plist);
	SLTNode* pos = SLTFind(plist, 3);
	pos->data = 30;
	SLInsert(&plist, pos, 20);
	SLTPrint(plist);
	SLInsertAfter(pos, 40);
	SLTPrint(plist);
	SLEraseAfter(pos);
	SLTPrint(plist);
	SLTDestroy(plist);
}
int main()
{
    
    
	test4();
	return 0;
}

listnode.c

#define _CRT_SECURE_NO_WARNINGS 1
#include "listnode.h"

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

SLTNode* BuyLTNode(SLTDataType x)
{
    
    
	SLTNode* newnode = (SLTNode*)malloc(sizeof(SLTNode));
	if (newnode == NULL)
	{
    
    
		perror("malloc fail");
		return NULL;
	}
	newnode->data = x;
	newnode->next = NULL;
	return newnode;
}
void SLTPushBack(SLTNode** pphead, SLTDataType x)
{
    
    
	assert(pphead);
	SLTNode* newnode = BuyLTNode(x);
	if ((*pphead) == NULL)
	{
    
    
		*pphead = newnode;
	}
	else
	{
    
    
		SLTNode* tail = *pphead;
		while (tail->next)
		{
    
    
			tail = tail->next;
		}
		tail->next = newnode;
	}
}
void SLTPushFront(SLTNode** pphead, SLTDataType x)
{
    
    
	assert(pphead);
	SLTNode* newnode = BuyLTNode(x);
	newnode->next = *pphead;
	*pphead = newnode;
}
//尾删的第一种方式
void SLTPopBack(SLTNode** pphead)
{
    
    
	//当只有一个节点的时候
	//多个节点
	assert(pphead);
	assert(*pphead);
	if ((*pphead)->next == NULL)
	{
    
    
		free(*pphead);
		*pphead = NULL;
	}
	else
	{
    
    
		SLTNode* tail = *pphead;
		SLTNode* prev = NULL;
		while (tail->next)
		{
    
    
			prev = tail;
			tail = tail->next;
		}
		free(tail);
		prev->next = NULL;
	}
}
//尾删的第二种方式
/*
void SLTPopBack(SLTNode** pphead)
{
	SLTNode* tail = *pphead;
	while (tail->next->next)
	{
		tail = tail->next;
	}
	free(tail->next);
	tail->next = NULL;
}
*/
void SLTPopFront(SLTNode** pphead)
{
    
    
	//空链表
	assert(*pphead);
	assert(pphead);
	SLTNode* prev = *pphead;
	*pphead = prev->next;
	free(prev);
	//一个节点
	//if ((*pphead)->next == NULL)
	//{
    
    
	//	free(*pphead);
	//	*pphead = NULL;
	//}
	多个节点
	//else
	//{
    
    
	//	SLTNode* prev = *pphead;
	//	*pphead = prev->next;
	//	free(prev);
	//}
}

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


//在pos之前插入
void SLInsert(SLTNode** pphead, SLTNode* pos, SLTDataType x)
{
    
    
	assert(pphead);
	assert(pos);
	if (*pphead == pos)
	{
    
    
		SLTPushFront(pphead, x);
	}
	else
	{
    
    
		SLTNode* prev = *pphead;
		while (prev->next != pos)
		{
    
    
			prev = prev->next;
		}
		SLTNode* newnode = BuyLTNode(x);
		prev->next = newnode;
		newnode->next = pos;
	}
	
}
void SLInsertAfter(SLTNode* pos, SLTDataType x)
{
    
    
	assert(pos);
	SLTNode* newnode = BuyLTNode(x);
	newnode->next = pos->next;
	pos->next = newnode;
}
//删除pos位置的值
void SLErase(SLTNode** pphead, SLTNode* pos)
{
    
    
	assert(pphead);
	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 SLEraseAfter(SLTNode* pos)
{
    
    
	assert(pos);
	assert(pos->next);
	SLTNode* next = pos->next;
	pos->next = next->next;
	free(next);
}

void SLTDestroy(SLTNode* phead)
{
    
    
	SLTNode* cur = phead;
	while (cur)
	{
    
    
		phead = phead->next;
		free(cur);
		cur = phead;
	}
}

listnode.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 SLTPrint(SLTNode* phead);
void SLTPushBack(SLTNode** pphead, SLTDataType x);
void SLTPushFront(SLTNode** pphead, SLTDataType x);

void SLTPopBack(SLTNode** pphead);
void SLTPopFront(SLTNode** pphead);

SLTNode* SLTFind(SLTNode* phead, SLTDataType x);

//在pos之前插入
void SLInsert(SLTNode** pphead,SLTNode* pos, SLTDataType x);
void SLInsertAfter(SLTNode* pos, SLTDataType x);
//删除pos位置的值
void SLErase(SLTNode** pphead, SLTNode* pos);
void SLEraseAfter(SLTNode* pos);

void SLTDestroy(SLTNode* phead);

总结

好啦，今天的单链表的大部分解决思路我都给大家详细的写出来啦！我们下期再见！嘿我们天天见！！！