数据结构 —— 单链表

1. 链表的概念及结构

       单链表是一种链式存取的数据结构，用一组地址任意的存储单元存放线性表中的数据元素。链表中的数据是以结点来表示的，每个结点的构成：元素(数据元素的映象) + 指针(指示后继元素存储位置)，元素就是存储数据的存储单元，指针就是连接每个结点的地址数据。

       如上图所示，每一个 val和*p next 叫做一个节点，在计算机内部存储的时候就可以不需要一片连续空间。 节点的组成主要有两个部分：当前节点要保存的数据和保存下⼀个节点的地址（指针变量）。

        所以在创建链表的时候，由于它要存储多个值（val 和下一个节点的地址），因此我们就定义一个结构体，用来将链表的 val 和下一个节点地址封装在一起。

     如图，像这样的话，用链表就是这样展示的：

       这里就只是简单的展示一下，上面红色就是val值，下面黑色就是下一个节点的地址，要注意的是，如果最后一个节点后面没有节点了，要将 *p next 置为空。 

        为什么还需要指针变量来保存下⼀个节点的位置？ 链表中每个节点都是独⽴申请的（即需要插⼊数据时才去申请⼀块节点的空间），我们需要通过指针 变量来保存下⼀个节点位置才能从当前节点找到下⼀个节点。

       接下来就用一个结构体演示一个节点的特征：

 struct SListNode
{
    int val;       //节点数据
 
    struct SListNode* next; //指针变量⽤保存下⼀个节点的地址
};
 

       当我们想要保存⼀个整型数据时，实际是向操作系统申请了⼀块内存，这个内存不仅要保存整型数据，也需要保存下⼀个节点的地址（当下⼀个节点为空时保存的地址为空）。

           当我们想要从第⼀个节点⾛到最后⼀个节点时，只需要在前⼀个节点拿上下⼀个节点的地址（下⼀个节点的钥匙）就可以了。 

思考：当我们想保存的数据类型为字符型、浮点型或者其他⾃定义的类型时，该如何修改？

对于这个问题，常使用typedef来重命名解决。

typedef int SLDataType;
struct SListNode
{
    SLDataType val;       //节点数据
 
    struct SListNode* next; //指针变量⽤保存下⼀个节点的地址
};
 

       这样的话，如果下一次存入 char 类型就可以直接将 int 改为 char 即可。（typedef char SLDataType） 

2. 实现单链表

 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);

 //在指定位置之前插⼊数据
void SLTInsert(SLTNode** pphead, SLTNode* pos, SLTDataType x);

 //删除pos节点 
void SLTErase(SLTNode** pphead, SLTNode* pos);

 //在指定位置之后插⼊数据 
void SLTInsertAfter(SLTNode* pos, SLTDataType x);

 //删除pos之后的节点
void SLTEraseAfter(SLTNode* pos);

 //销毁链表
 void SListDesTroy(SLTNode** pphead);

       单链表的常见操作就如上所示，接下来将为大家一一演示一遍。 

2.1 节点的创建及链表

先在头文件  SListNode.h  定义结构体，

因为链表不需要一片连续空间，所以申请空间使用 malloc 即可，在用next指针连在一起。 

//SListNode.h
#pragma once
#include<stdio.h>
#include<stdlib.h>
#include<assert.h>

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

//test.c

SLTNode* node1 = (SLTNode*)malloc(sizeof(SLTNode));
node1->val = 1;
SLTNode* node2 = (SLTNode*)malloc(sizeof(SLTNode));
node2->val = 2;
SLTNode* node3 = (SLTNode*)malloc(sizeof(SLTNode));
node3->val = 3;
SLTNode* node4 = (SLTNode*)malloc(sizeof(SLTNode));
node4->val = 4;
node1->next = node2;
node2->next = node3;
node3->next = node4;
node4->next = NULL;

2.2 链表的打印

打印之前，断言一下链表是否为空。

//链表打印
void SLTPrint(SLTNode* phead)
{
	assert(phead);
	while (phead)
	{
		printf("%d ", phead->val);
		phead = phead->next;
	}
	printf("\n");
}

2.3 链表的插入

2.3.1 创建节点

这一步主要是为了后续添加数据方便而单独创建一个节点函数。

//创建节点
SLTNode* SLTBuyNode(SLTDataType x)
{
    SLTNode* newnode = (SLTNode*)malloc(sizeof(SLTNode));
    if (newnode == NULL)
    {
        perror("malloc fail!");
        return 1;
    }
    newnode->val = x;
    newnode->next = NULL;
    return newnode;
} 

2.3.2 尾插 

链表尾插时，一定要注意判断链表是否为空，

1.为空就直接将 newnode 给看成头节点即可

2.不为空，就找尾，将尾指针的 next 指向 newnode ,

//链表尾插
void SLTPushBack(SLTNode** pphead, SLTDataType x)
{
	//先要创建一个节点
	SLTNode* newnode = SLTBuyNode(x);
	//尾插考虑链表是否为空
	//1.如果链表为空
	if (*pphead == NULL)
	{
		*pphead = newnode;
	}
	//2.链表不为空
	//找尾
	else
	{
		SLTNode* ptail = *pphead;
		while (ptail->next)
		{
			ptail = ptail->next;
		}
		//跳出循环，来到尾
		ptail->next = newnode;
	}
}

 2.3.3 头插

//头插
void SLTPushFront(SLTNode** pphead, SLTDataType x)
{
	assert(pphead);
	//先要创建一个节点
	SLTNode* newnode = SLTBuyNode(x);
	newnode->next = *pphead;
	*pphead = newnode;
}

2.3.4 在指定位置之前插入 

两种情况：

1.在头节点插入，直接调用头插即可

2.在 pos 之前插入

newnode->next  = pos 

prev->next = newnode  两个代码位置不可以交换！！！

否则就是下图所示：

//在指定位置之前插⼊数据
void SLTInsert(SLTNode** pphead, SLTNode* pos, SLTDataType x)
{
	assert(pphead);
	assert(*pphead);
	assert(pos);
	//1.pos在头节点
	if (pos == *pphead)
	{
		SLTPushFront(pphead, x);
	}
	else
	{
		SLTNode* newnode = SLTBuyNode(x);
		newnode->next = pos;
		SLTNode* prve = *pphead;
		while (prve->next != pos)
		{
			prve = prve->next;
		}
		prve->next = newnode;
	}
}

2.3.5 在指定位置之前插入数据

//在指定位置之后插⼊数据 
void SLTInsertAfter(SLTNode* pos, SLTDataType x)
{
	assert(pos);
	SLTNode* newnode = SLTBuyNode(x);
	newnode->next = pos->next;
	pos->next = newnode;

}

2.4 链表的删除

2.4.1 尾删

需要考虑链表中节点个数

1.如果只有一个节点，直接  free  掉，然后制空。

2.有多个节点，先找到尾，

//尾删
void SLTPopBack(SLTNode** pphead)
{
	assert(pphead);
	assert(*pphead);
	//只有一个节点
	if ((*pphead)->next == NULL)
	{
		free(*pphead);
		*pphead = NULL;
	}

	//有多个节点
	else
	{
		SLTNode* ptail = *pphead;
		SLTNode* prve = *pphead;
		while (ptail->next)
		{
			prve = ptail;
			ptail = ptail->next;
		}

		free(ptail);
		ptail = NULL;
		prve->next = NULL;
		}
}

2.4.2 头删

//头删
void SLTPopFront(SLTNode** pphead)
{
    assert(pphead && *pphead);

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

2.4.3 删除 pos 节点

//删除pos节点 
void SLTErase(SLTNode** pphead, SLTNode* pos)
{
	assert(pphead && *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);
		pos = NULL;
	}

}

2.4.4 删除 pos 之后的节点

要注意的事删除 pos 节点之后的节点，所以 pos->next 也不可以为空

//删除pos之后的节点
void SLTEraseAfter(SLTNode* pos)
{
	assert(pos&&pos->next);
	SLTNode* del = pos->next;
	pos->next = pos->next->next;
	free(pos);
	pos = NULL;
}

2.5 链表的销毁

//销毁链表
void SListDesTroy(SLTNode** pphead)
{
	assert(pphead && *pphead);
	SLTNode* pcur;
	while (pcur)
	{
		SLTNode* next = pcur->next;
		free(pcur);
		pcur = next;
	}
	*pphead = NULL;
}

 3.链表的注意事项

要注意链表这里需要传二级指针。

4. 链表的分类

链表的结构⾮常多样，以下情况组合起来就有8种（2x2x2）链表结构：

       虽然有这么多的链表的结构，但是我们实际中最常⽤还是两种结构： 单链表 和 双向带头循环链表 。

1. ⽆头单向⾮循环链表：结构简单，⼀般不会单独⽤来存数据。实际中更多是作为其他数据结

构的⼦结构，如哈希桶、图的邻接表等等。另外这种结构在笔试⾯试中出现很多。

2. 带头双向循环链表：结构最复杂，⼀般⽤在单独存储数据。实际中使⽤的链表数据结构，都

是带头双向循环链表。另外这个结构虽然结构复杂，但是使⽤代码实现以后会发现结构会带

来很多优势，实现反⽽简单了，后⾯我们代码实现了就知道了。

最后欢迎大家有什么问题可以补充说明，感谢。