链表的回顾

一、链表的概念及结构

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

结构：通常的，链表的每个节点中都被分为两个部分：当前节点要保存的数据和保存下一个节点的地址（指向下一个节点的指针）。

 
struct SListNode
{
    int data;//节点数据
    struct SListNode* next;//指向下一个节点的指针
};

二、链表的分类

链表根据不同的特点分类可以有带头、不带头，单向、双向，循环、不循环，一共8种（2 x 2 x 2）。

其中，常见的链表有两种：一种是不带头单向不循环链表（单链表），一种是带头双向循环链表（双链表）。

三、几种常见的链表操作（以单链表为例）

//以下列链表结构为例
typedef struct SListNode {
	SLTDataType data;
	struct SListNode* next;
}SLTNode;

1、链表节点的开辟

SLTNode* SLTBuyNode(SLTDataType x) 
{
	SLTNode* newnode = (SLTNode*)malloc(sizeof(SLTNode));
	if (newnode == NULL)
	{
		perror("malloc fail!");
		exit(1);
	}
	newnode->data = x;
	newnode ->next = NULL;

	return newnode;
}

2、链表的尾插

代码实现如下：

void SLTPushBack(SLTNode** pphead, SLTDataType x)
{
	assert(pphead);//判空
	SLTNode* newnode = SLTBuyNode(x);//创建新节点
	if (*pphead == NULL)//当链表为空
	{
		*pphead = newnode;//新的节点就作为头节点
	}
	else {
		SLTNode* ptail = *pphead;
		while (ptail->next)
		{
			ptail = ptail->next;//找到尾节点
		}
		ptail->next = newnode;//尾节点的next指针指向newnode
	}
}

3、链表的头插

void SLTPushFront(SLTNode** pphead, SLTDataType x)
{
	assert(pphead);
	SLTNode* newnode = SLTBuyNode(x);
	if (*pphead == NULL)
	{
		*pphead = newnode;
	}
	else {
		SLTNode* pcur = *pphead;//先把原来的头节点存到pcur中
		*pphead = newnode;//将新节点给头节点
		newnode->next = pcur;//让新节点的next指向原来的头节点
	}
}

4、链表的尾删

void SLTPopBack(SLTNode** pphead)
{
	assert(pphead && *pphead);
	//链表只有一个节点
	if ((*pphead)->next == NULL)
	{
		free(*pphead);//释放头节点
		*pphead = NULL;//置空
	}
	else {
		SLTNode* prev = *pphead;//prev为前节点
		SLTNode* ptail = *pphead;//ptail为尾节点
		while (ptail->next != NULL)
		{
			prev = ptail;//找尾节点的前一个节点
			ptail = ptail->next;//找尾
		}
		free(ptail);//释放尾节点
		ptail = NULL;
		prev->next = NULL;//让新尾节点的next指向空
	}
}

5、链表的头删

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

6、链表节点的查找

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

7、在指定位置之前插入数据

void SLTInsert(SLTNode** pphead, SLTNode* pos, SLTDataType x)
{
	assert(pphead && *pphead);
	assert(pos);
	SLTNode* newnode = SLTBuyNode(x);
	if (pos == *pphead)//如果指定位置为头节点，直接调用头插
	{
		SLTPushFront(pphead, x);
	}
	else {
		SLTNode* prev = *pphead;
		while (prev->next != pos)
		{
			prev = prev->next;//把指定位置的前一个节点先找到
		}
		newnode->next = pos;//让新节点的next指向指定位置
		prev->next = newnode;//让原指定位置前的节点的next指向新节点
	}
}

8、在指定位置之后插入数据

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

9、删除指定节点

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

10、删除指定位置之后的节点

void SLTEraseAfter(SLTNode* pos)
{
	assert(pos && pos->next);
	SLTNode* next = pos->next;
	pos->next = pos->next->next;
	free(next);
	next = NULL;
}

11、销毁链表

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