单链表的基本应用

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

概念模型即：

用地址表示的话就是 如下图链表分为单向，双向，带环，不带环，带头，无头的链表。

今天我所写的链表是关于单向不带环无头的单链表，也是最基本的链表。

概念模型即

首先我们需要认识一下链表的基本组成部分：链表节点

链表节点即为定义的结构体，其中有存储数据的元素和指向下一节点的指针元素（最基本的两个元素，到后面会有更复杂的）。

typedef struct SQList
{
	int data;
	struct SQList* next;
}SL;

代码所写的data的类型是任意类型的，但是为了方便，我定义为int型，便于理解。

链表要以动态开辟的内存作为节点，这样能够做到用多少内存，开多少内存，即用malloc开辟空间

SL* CreateNewNode(int x)
{
	SL* newNode = (SL*)malloc(sizeof(SL));
	if (newNode == NULL)
	{
		perror("CreateNewNode::");
		return NULL;
	}
	else
	{
		newNode->data = x;
		newNode->next = NULL;
		return newNode;
	}
}

可以看到为防止开辟空间失败，我们可以严谨的用if条件句进行判断及时终止，并用perror打印错误信息。

对一个链表最基本的操作即为增，删，查，改。

1.  先从增（增加节点）开始

增加节点分为三个类型

• 尾插
• 头插
• 中间插入

尾插：

分为两个部分，根据是否存在头节点进行分类，若没有头节点，则将新节点直接作为头节点。

        若存在头节点，则需要一个变量cur找到尾节点，在插入新的节点。

        在寻找尾节点时，用while循环，可以用cur直接作为判断条件，走到NULL，循环终止，但此时无法找到尾节点的位置，因此我们需要一个prev变量记录cur的前一个位置。

       （如果在while循环中用cur->next作为判断条件则不需要prev变量，纯属看个人习惯）

SListPushBack(SL** phead, int x)
{
	SL* newNode = CreateNewNode(x);
	if ((*phead) == NULL)
	{
		*phead = newNode;
	}
	else
	{
		SL* prev = NULL;
		SL* cur = *phead;
		while (cur)
		{
			prev = cur;
			cur = cur->next;
		}
		cur = newNode;
		prev->next = cur;
	}
}

头插：相对于尾插来说，比较简单，因为他即将成为新的头节点，他不需要关注是否有头节点，话不多说直接上代码。

void SListPushFront(SL** phead,int x)
{
	assert(*phead);
	SL* newnode = CreateNewNode(x);
	newnode->next = *phead;
	*phead = newnode;
}

assert断言函数，可以在每一个链表函数的第一句写上，能够判断链表是否为空，更加严谨

中间插入：

思路：首先通过一个while循环找到插入中间插入节点的位置，在进行插入，将前者的next指向新节点，新节点的next指向下一个节点。如果是插入第一个位置，则直接调用头插函数，节省代码量。

void SListInsert(SL** phead, int pos, int x)
{
	assert(*phead);
	if (pos == 0)
	{
		SListPushFront(&(*phead), x);
		return;
	}
	SL* newnode = CreateNewNode(x);
	SL* cur = *phead;
	SL* prev = NULL;
	while (pos--)
	{
		prev = cur;
		cur = cur->next;
	}
	prev->next = newnode;
	newnode->next = cur;
}

增的基本函数就这三种，还是比较好理解的，希望大家可以有所收获。

接下来我们将一下删

        2.删：

删也分为三种，和增对应，头删，尾删，中间删，主要讲一下头删和尾删

• 头删:

头节点的删除，意味着需要删除头节点的同时，将下一个节点作为新的头节点，否则链表就找不到了，而删除链表节点，就用malloc对应的free函数，用一个变量记头节点的next作为新的头节点，然后将头节点free掉，不要忘了将其置空，虽然不影响大局，但是好的习惯就在平常养成~

void SListPopBack(SL** phead)
{
	assert(*phead);
	if ((*phead)->next == NULL)
	{
		free(*phead);
		*phead = NULL;
		return;
	}
	SL* cur = *phead;
	SL* prev =	NULL;
	while (cur->next!= NULL)
	{
		prev = cur;
		cur = cur->next;
	}
	free(cur);
	cur = NULL;
	prev->next = NULL;
}

• 尾删

尾删比较好理解，就是找到最后一个尾节点，再将其释放掉就ok了，没有什么重点，不做过多赘述

void SListPopFront(SL** phead)
{
	assert(*phead);
	if ((*phead)->next == NULL)
		free(*phead);
	else
	{
		SL* cur = (*phead)->next;
		free(*phead);
		*phead = cur;
	}
}

 3.查：

查找特定链表，需要我们遍历整个链表，然后一一比对，将要找到的链表返回，找不到就返回空指针NULL，即可完成查的功能.

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

       4.改：

只需要用查的函数，将需要修改的链表找到，再进行修改即可，直接上代码。

void SListModify(SL** plist, int x, int y)
{
	assert(*plist);
	SL* node = NULL;
	node = SListFind(*plist, x);
	if (node == NULL)
		return;
	node->data = y;
}

最后一点也很重要

链表的释放：

链表使用完需要我们一个一个节点去释放，不然会导致内存泄漏等问题，我们只需要用while循环以头节点遍历整个链表，再用free函数依次释放即可。最后别忘了把头节点置空！

void SListDestroy(SL** phead)
{
	assert(*phead);
	SL* cur = *phead;
	while (cur)
	{
		SL* next = cur->next;
		free(cur);
		cur = next;
	}
	*phead = NULL;
}

以上就是单链表的基本应用，增删查改，是链表的基础，单链表主要是用于做题中使用，需要熟练掌握这些基础方法，在实际应用中双链表更为方便，希望这篇文章对你的单链表知识有所提升。