数据结构初阶之单链表（C语言实现）

接着上节的顺序表来看，我们其实可以看到顺序表的缺陷：
1. 中间/头部的插入删除，时间复杂度为O(N)

2. 增容需要申请新空间，拷贝数据，释放旧空间。会有不小的消耗。

3. 增容一般是呈2倍的增长，势必会有一定的空间浪费。例如当前容量为100，满了以后增容到 200，我们再继续插入了5个数据，后面没有数据插入了，那么就浪费了95个数据空间。

这些其实都可以通过链表的方式来解决。

所以更新单链表的接口函数C语言实现：（重点内容）

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

链表的方式一共有八种，分别是单向双向，带头不带头，循环非循环的排列组合。

今天实现的就是单向不带头非循环的接口函数，也是最常用的。

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

在单向非循环链表这里有比较多的OJ，题目我会在leetcode专栏中更新，敬请移步：

数据结构初阶leetcode刷题合集（C语言实现，不定期更新）_何以过春秋的博客-CSDN博客

无头单项非循环链表实现：

首先来看看它的定义和接口函数有哪些：

#pragma once

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

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

SLTNode* BuySListNode(SLTDataType x);
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 SListErase(SLTNode** pphead, SLTNode* pos);

首先链表的节点使用结构体来定义，按照之前和顺序表一样的写法，typedef一下，方便以后使用，单向不带头非循环的链表包含一个元素一个指针，结构体定义如代码所示，方便理解放张图：

 其中C元素包含的指针指向NULL。

单链表接口函数功能其实也是为了实现数据的增删查改，下面就开始具体实现：

第一个功能：打印

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)

这里首先需要注意的就是，关于一级指针传值，二级指针传址的问题，

两者的区别在于是否想要修改头指针所指向的空间内容。

第一个打印函数完全不需要修改头指针，而第二个尾插函数在链表为空时尾插的时候，就需要改变链表的头指针所指向的内容，因为头指针原来为空，在尾插后，头指针需要指针头元素，所以需要二级指针传参。

尾插的思路就是，无论链表是否为空，首先都需要malloc一个节点出来，如果为空，则该节点为插入对象，且改变头指针指向，若不为空，则需要找尾，需要定义一个tail指针，来找到当前链表的尾，然后用尾的next指向新节点。

下面这段代码将定义一个新节点单独封装为一个返回值函数。

SLTNode* BuySListNode(SLTDataType x)
{
	SLTNode* newnode = (SLTNode*)malloc(sizeof(SLTNode));
	assert(newnode);
	newnode->data = x;
	newnode->next = NULL;

	return newnode;
}

void SListPushBack(SLTNode** pphead, SLTDataType x)
{
	SLTNode* newnode = BuySListNode(x);

	if (*pphead == NULL)
	{
		*pphead = newnode;
	}
	else
	{
		// 找尾节点
		SLTNode* tail = *pphead;
		while (tail->next != NULL)
		{
			tail = tail->next;
		}

		tail->next = newnode;
	}
}

第三个功能：头插

这里也是传二级指针，并且不需要考虑为空的情况，只要开辟出来并且将头指针指向新头即可。

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

第四个功能：尾删

首先删除的时候需要考虑链表是否为空的情况，如果链表为空，这时是没有办法删除的，因为可能会free掉不属于链表的内容，所以要加一个assert来断言，防止程序出错。若不为空，也注意不要删到空之后还继续删。

对于普通的尾删，分为删除只有一个节点和多个节点。对于一个节点，直接free，然后把头指针置空。对于多个节点，其实就是free掉尾节点，然后用次尾节点连起来，尾节点和次尾节点的寻找都需要分别定义指针来维护。下图其实通过两种方式来实现的，前一种定义了双指针，后一种没有定义，后面一种效率更高一点。

void SListPopBack(SLTNode** pphead)
{
	assert(*pphead);

	// 1、只有一个节点
	// 2、多个节点
	if ((*pphead)->next == NULL)
	{
		free(*pphead);
		*pphead = NULL;
	}
	else
	{
		SLTNode* tailPrev = NULL;
		SLTNode* tail = *pphead;
		while (tail->next != NULL)
		{
			tailPrev = tail;
			tail = tail->next;
		}
		free(tail);
		tailPrev->next = NULL;





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

第五个功能：头删

其实还是首先考虑不能删除空链表，不为空删除的话，需要定义一个指针来维护头节点，因为如果不定义的话，把传参传过来的头指针free掉之后，就找不到下一个节点了。

void SListPopFront(SLTNode** pphead)
{
	assert(*pphead != NULL);
	//if (*pphead == NULL)
	//	return;

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

第六个功能：查找

整个非常简单，对应给定的x值直接进去找就可以

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

		cur = cur->next;
	}

	return NULL;
}

第七个功能：在pos位置插入一个节点

这里需要在函数参数方面需要注意，在pos位置我们使用类似数组的访问方式（下标），我们使用pos指针指向的元素，这时一种默认的习惯

void SListInsert(SLTNode** pphead, SLTNode* pos, SLTDataType x)

这里的逻辑就是分两种情况，pos就是pphead和pos不是pphead，如果是，则就是头插，如果不是，则需要找到pos位置和pos前一个位置，创建一个新节点，然后链接起来即可

void SListInsert(SLTNode** pphead, SLTNode* pos, SLTDataType x)
{
	assert(pphead);
	assert(pos);

	// 1、pos是第一个节点
	// 2、pos不是第一个节点
	if (pos == *pphead)
	{
		SListPushFront(pphead, x);
	}
	else
	{
		SLTNode* prev = *pphead;
		while (prev->next != pos)
		{
			prev = prev->next;
		}

		SListNode* newnode = BuySListNode(x);
		prev->next = newnode;
		newnode->next = pos;
	}
}

第八个功能：删除pos位置

逻辑跟第七个一样，若空，就是头删，不为空，就是找到pos前一个位置，free掉pos位置节点，然后和pos之后的节点连起来

void SListErase(SListNode** pphead, SListNode* pos)
{
	assert(pphead);
	assert(pos);

	if (*pphead == pos)
	{
		SListPopFront(pphead);
	}
	else
	{
		SLTNode* prev = *pphead;
		while (prev->next != pos)
		{
			prev = prev->next;
		}

		prev->next = pos->next;
		free(pos);
		pos = NULL;
	}
}

接下来的功能其实就是insertafter和eraseafter，和前面的功能是一样的，但是逻辑方面却更加简单。

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

void SListEraseAfter(SListNode* pos)
{
	assert(pos);

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

最后一个功能是销毁单链表

这里需要注意的有两点，第一点就是free掉当前的节点之后下个节点如何寻找，第二个就是程序最后要将传过来的pphead置空。

void SListDestroy(SListNode** pphead)
{
	assert(pphead);

	SLTNode* cur = *pphead;
	while (cur)
	{
		SListNode* next = cur->next;
		free(cur);
		cur = next;
	}

	*pphead = NULL;
}