【数据结构】超详细--单向链表

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

实际中链表的结构非常多样，主要有以下几种链表结构：

a.单向或者双向

b.带头或者不带头

c.循环或非循环

虽然有这么多的链表结构，但是我们实际中最常用的还是无头单向非循环和带头双向循环结构。其中无头单项循环是其他几种的基础，为了便于接下来的带头循环链表，本文对下图无头单向链表进行解析。

1、构建基本的单向链表

首先，上图中的链表每一块空间都是由数据和下一个空间的地址组成，那么这块空间的组成详见下面的代码：

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

1.1 开辟链表

对于添加的每一个字符，都开辟一块空间：

SLTNode* BuySLTNode(SLTDtatType x)
{
	SLTNode* newnode = (SLTNode*)malloc(sizeof(SLTDtatType));
	if (newnode == NULL)
	{
		perror("malloc fail");
		exit(-1);
	}

	newnode->data = x;
	newnode->next = NULL;

	return newnode;
}

1.2 创建链表

在创建链表的函数中调用开辟空间的链表，该函数中内一个结点空间都来源于开辟链表函数，在完成创建链表这个过程后，将表头phead的值返回。

SLTNode* CreateSList(int n)
{
	SLTNode* phead = NULL, * ptail = NULL;
	for (int i = 0; i < n; i++)
	{
		SLTNode* newnode = BuySLTNode(i);
		if (phead == NULL)
		{
			ptail = phead = newnode;
		}
		else
		{
			ptail->next = newnode;
			ptail = newnode;
		}
	}
    return phead;
}

1.3 打印模块

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

1.4 测试及结果：

测试一

void TestSList01()
{
	SLTNode* n1 = BuySLTNode(1);
	SLTNode* n2 = BuySLTNode(2);
	SLTNode* n3 = BuySLTNode(3);
	SLTNode* n4 = BuySLTNode(4);
	SLTNode* n5 = BuySLTNode(5);
	n1->next = n2;
	n2->next = n3;
	n3->next = n4;
	n4->next = n5;
	n5->next = NULL;
}

代码执行完SLTNode* n5之后，链表的各个空间的值都赋完，但结构中存储的下一个空间的地址都为空；接下来给需要存储的下一个空间地址赋值，结果如下：

测试二

void TestSList02()
{
	SLTNode* plist = CreateSList(5);
	SLTPrint(plist);
}

一个连续赋值的单向链表结果如下：

此外，链表的操作不仅仅读写，还涉及到增删改查，详细见下面几节。

2、尾插与尾删

链表的尾部的数值插入及删除，具体如下：

2.1 尾插

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

首先，创建新的结点作为新开辟的链表空间，接着检查新开辟的结点是否为空，为空则将该结点赋给旧链表，否则通过tail来找链表的尾部后将newnode的地址赋给尾部的next。

2.2 尾删

void SLTPopBack(SLTNode** pphead)
{
	assert(*pphead);
	if ((*pphead)->next = NULL)
	{
		free(*pphead);
		*pphead = NULL;
	}
	else
	{
		SLTNode* tail = *pphead;
		while (tail->next->next)
		{
			tail = tail->next;
		}
		free(tail->next);
		tail->next = NULL;
	}
}

首先检查链表是否在堆上只占有一个空间，若是则释放链表pphead；若不是，则通过tail来找尾，找到后立即释放链表的尾部。

2.3 测试及结果

void TestSList02()
{
	SLTNode* plist = CreatList(5);
	SLTPrint(plist);

	SLTPushBack(&plist, 500);
	SLTPrint(plist);

	SLTPopBack(&plist);
	SLTPrint(plist);
}

3、头插与头删

3.1 头插

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

链表的头插相对于顺序表的头插而言较简单，直接将新的结点的下一个指向地址赋链表的头地址，并将新结点重新定义为链表的头部。

3.2 头删

void SLTPopFront(SLTNode** pphead)
{
	assert(*pphead);
	SLTNode* next = (*pphead)->next;
	free(*pphead);
	*pphead = next;
}

断言链表是否为空，定义好链表头部的下一个结点next后，释放链表的头部，并将next作为链表的头部。

3.3 测试及结果:

void TestSList03()
{
	SLTNode* plist = CreatList(5);
	SLTPrint(plist);

	SLTPushFront(&plist, 100);
	SLTPrint(plist);

	SLTPopFront(&plist);
	SLTPrint(plist);
}

4、任意位置后插入及删除

4.1 任意位置后插入

void SLTInsertAfter(SLTNode* pos, SLTDataType x)
{
	assert(pos);
	SLTNode* newnode = BuySLTNode(x);

	newnode->next = pos->next;
	pos->next = newnode;
}

将插入位置pos->next的地址直接赋给newnode->next后，更新pos->next的地址为newnode的地址。

4.2 任意位置后删除

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

4.3 测试及结果：

void TestSList04()
{
	SLTNode* plist = CreatList(5);
	SLTPrint(plist);

	SLTNode* p = SLTFind(plist, 3);
	SLTInsertAfter(p, 30);
	SLTPrint(plist);

	SLTEraseAfter(p);
	SLTPrint(plist);
}

5、任意位置前插入及删除

5.1 任意位置前插入

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

	if (*pphead == pos)
	{
		SLTPushFront(pphead, x);
	}
	else
	{
		SLTNode* prev = *pphead;
		while (prev->next != pos)
		{
			prev = prev->next;
		}
		SLTNode* newnode = BuySLTNode(x);
		prev->next = newnode;
		newnode->next = pos;
	}
}

若pos的位置为链表的头部，则直接调用第3节的头插。

其后具体操作如上图所示。

5.2 任意位置前删除

void SLTErase(SLTNode** pphead, SLTNode* pos)
{
	assert(pos);

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

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

5.3 测试及结果

void TestSList05()
{
	SLTNode* plist = CreatList(5);
	SLTPrint(plist);

	SLTNode* p = SLTFind(plist, 4);
	SLTInsert(&plist,p, 40);
	SLTPrint(plist);

	SLTErase(&plist,p);
	SLTPrint(plist);
}

如有疑问，请在评论区指点！