对单链表和带头双向循环链表的理解（二级指针问题）

---

---

前言

在数据结构中，链表是一个非常重要的内容，而链表可以分为带头和不带头，循环和不循环，单向和双向，今天我们将介绍最常用的两种——无头单向非循环链表和带头双向循环链表，掌握了这两种，那么另外几种也就可以举一反三了 。

---

一、无头单向非循环链表

1.结构及接口的定义

我们可以画出它的逻辑结构：

所以我们可以知道，一个小的结点需要包含不同的数据类型，所以我们自然而然的想到了用结构体的知识。我们可以按如下定义其结构：

typedef int SLTDataType;

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

由于我们储存的数据不一定都是整数类型，所以我们利用了typedef来定义数据类型，以便后面需要更改，这也是我们在数据结构学习中的一个好习惯。

我们可以利用链表来进行增删查改等操作，所以我们可以定义如下接口：

//创建一个新的结点
SListNode* BuySListNode(SLTDataType x);
//打印
void SListPrint(SListNode* plist);
//摧毁链表
void SListDestory(SListNode** pplist);

//尾插
void SListPushBack(SListNode** pplist, SLTDataType x);
//头插
void SListPushFront(SListNode** pplist, SLTDataType x);
//尾删
void SListPopBack(SListNode** pplist);
//头删
void SListPopFront(SListNode** pplist);

//单链表查找
SListNode* SListFind(SListNode* plist,SLTDataType x);

//单链表前插
void SListInsertFront(SListNode** pplist,SListNode* pos, SLTDataType x);

//单链表后插
void SListInsertAfter(SListNode** pplist, SListNode* pos, SLTDataType x);

//单链表删除
void SListEraseAfter(SListNode** pplist,SLTDataType x);

2.接口的实现

我们通过遍历链表来逐一打印每个元素：

void SListPrint(SListNode* plist)
{
	SListNode* cur = plist;
	while (cur)
	{
		printf("%d->", cur->data);
		cur = cur->next;
	}
	printf("NULL\n");
}

该接口是用来创建一个新的结点并赋值，配合后面插入接口使用

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

在这里我们有两种插入方式，头插和尾插，尾插分为两种情况，链表为空时和不为空时。

//尾插
void SListPushBack(SListNode** pplist, SLTDataType x)
{
	assert(pplist);
	SListNode* newnode = BuySListNode(x);

	if (*pplist == NULL)
	{
		*pplist = newnode;
	}
	else
	{
		SListNode* cur = *pplist;
		while (cur->next)
		{
			cur = cur->next;
		}

		cur->next = newnode;
		//newnode->next=NULL;
	}
}


//头插
void SListPushFront(SListNode** pplist, SLTDataType x)
{
	assert(pplist);
	SListNode* newnode = BuySListNode(x);
	newnode->next = *pplist;
	*pplist = newnode;
}

我们删除也有两种方式，头删和尾删，尾删时也需要分为两种情况，分别是链表为空和不为空。

//尾删
void SListPopBack(SListNode** pplist)
{
	assert(pplist);
	if (*pplist == NULL)
		return;

	if ((*pplist)->next == NULL)
	{
		free(*pplist);
		*pplist == NULL;
	}
	else
	{
		SListNode* cur = *pplist;
		while (cur->next->next)
		{
			cur = cur->next;
		}

		free(cur->next);
		cur->next = NULL;
	}
}


//头删
void SListPopFront(SListNode** pplist)
{
	assert(pplist);

	if (*pplist == NULL)
		return;

	SListNode* del = *pplist;
	*pplist = (*pplist)->next;
	free(del);
	del = NULL;
}

下面是剩余接口:

//单链表查找
SListNode* SListFind(SListNode* plist, SLTDataType x)
{
	SListNode* cur = plist;
	while (cur)
	{
		if (cur->data == x)
		{
			return cur;
		}
		cur = cur->next;
	}
	return NULL;
}


//单链表插入
void SListInsertFront(SListNode** pplist ,SListNode* pos, SLTDataType x)
{
	assert(pplist);
	assert(pos);

	if (pos == *pplist)
	{
		SListPushFront(pplist, x);
	}
	else
	{
		SListNode* cur = *pplist;
		while (cur->next != pos)
		{
			cur = cur->next;
			assert(cur);
		}

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

void SListInsertAfter(SListNode** pplist, SListNode* pos, SLTDataType x)
{
	assert(pos);

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

//单链表删除
void SListEraseAfter(SListNode** pplist,SLTDataType x)
{
	assert(pplist);
	SListNode* cur = *pplist;
	SListNode* temp;
	if (cur->data==x)
	{
		/*temp = *pplist;
		*pplist = cur->next;
		free(temp);
		temp = NULL;
		return;*/

		SListPopFront(pplist);
		return;

	}
	while (cur)
	{
		if (cur->next->data == x)
		{
			temp = cur->next;
			cur->next = temp->next;
			free(temp);
		}
		cur = cur->next;
	}
}

//单链表摧毁
void SListDestory(SListNode** pplist)
{
	assert(pplist);

	SListNode* cur = *pplist;
	while (cur)
	{
		SListNode* next = cur->next;
		free(cur);
		cur = next;

	}
	*pplist = NULL;
}

3.对接口函数传二级指针的剖析

接下来将是我们本文的重点，首先我们以插入元素来开始分析：

在这里我们定义了一个结构体指针，指向了空：

然后我们进行尾插：

我们用newnode接收了一个新结点，此时pplist代表的是为pplist的解引用，而pplist是我们最初创建的plist指针的地址（后面我们会解释为什么要传plist的地址），所以我们通过pplist更改了plist的指向，让它指向了这个新结点。

然后我们尾插后面的元素，储存结构如下：

逻辑结构如下：

现在我们可以解释二级指针的问题，因为我们在插入第一个元素时，我们需要更改plist指向的内容，如果我们只传这个结构体指针，那么在函数中，形参的改变不会影响实参，所以需要传plist的地址，来达到更改plist的目的。但我们不一定要传二级指针，我们在接下来的带头双向循环链表将会介绍。

二、带头双向循环链表

1.结构及接口的定义

逻辑结构如下：

定义的结构如下：

typedef int SLDataTpye;

typedef struct ListNode {
	SLDataTpye data;
	struct ListNode* pre;
	struct ListNode* next;
}LTNode;

下面是带头双向循环链表的接口：

//初始化
LTNode* ListInit();
//打印
void ListPrint(LTNode* phead);
//摧毁
void ListDestory(LTNode* phead);

//尾插
void ListPushBack(LTNode* phead , SLDataTpye x);
//头插
void ListPushFront(LTNode* phead , SLDataTpye x);
//尾删
void ListPopBack(LTNode* phead);
//头删
void ListPopFront(LTNode* phead);

//判断空
bool ListEmpty(LTNode* phead);
//大小
size_t ListSize(LTNode* phead);
//查找
LTNode* ListFind(LTNode* phead,SLDataTpye x);

//插入
void ListInsert(LTNode* pos, SLDataTpye x);
//删除
void ListErase(LTNode* pos);

2.接口的实现

由于这些接口的实现可以参考单链表，难度不大，所以不对其进行逐一分析。

//初始化
LTNode* ListInit()
{
	LTNode* guard = (LTNode*)malloc(sizeof(LTNode));
	if (guard == NULL)
	{
		perror("malloc fail");
		return;
	}
	guard->pre = guard;
	guard->next = guard;

	return guard;
}

//打印
void ListPrint(LTNode* phead)
{
	assert(phead);

	printf("phead<=>");
	LTNode* cur = phead->next;
	while (cur != phead)
	{
		printf("%d<=>", cur->data);
		cur = cur->next;
	}
	printf("\n");
}

//创建新的结点
LTNode* ListBuyNode(SLDataTpye x)
{
	LTNode* newnode = (LTNode*)malloc(sizeof(LTNode));
	if (newnode == NULL)
	{
		perror("malloc fail");
		return;
	}
	newnode->data = x;
	newnode->next = NULL;
	newnode->pre = NULL;

	return newnode;
}

//尾插
void ListPushBack(LTNode* phead, SLDataTpye x)
{
	assert(phead);

	ListInsert(phead, x);
}

//头插
void ListPushFront(LTNode* phead , SLDataTpye x)
{
	assert(phead);

	ListInsert(phead->next, x);
}

//尾删
void ListPopBack(LTNode* phead)
{
	assert(phead);
	assert(!ListEmpty(phead));

	ListErase(phead->pre);
}

//头删
void ListPopFront(LTNode* phead)
{
	assert(phead);
	assert(!ListEmpty(phead));

	ListErase(phead->next);
}

//判断是否为空
bool ListEmpty(LTNode* phead)
{
	assert(phead);

	return phead == phead->next;
}

//大小
size_t ListSize(LTNode* phead)
{
	assert(phead);

	size_t count = 0;
	LTNode* cur = phead->next;
	while (cur != phead)
	{
		count++;
		cur = cur->next;
	}
	return count;
}

//查找
LTNode* ListFind(LTNode* phead, SLDataTpye x)
{
	assert(phead);

	LTNode* cur = phead->next;
	while (cur != phead)
	{
		if (cur->data == x)
		{
			return cur;
		}
		cur = cur->next;
	}

	return NULL;
}

//在pos之前插入
void ListInsert(LTNode* pos, SLDataTpye x)
{
	assert(pos);

	LTNode* pre = pos->pre;
	LTNode* newnode = ListBuyNode(x);
	
	pre->next = newnode;
	newnode->pre = pre;
	newnode->next = pos;
	pos->pre = newnode;

}

//删除pos位置
void ListErase(LTNode* pos)
{
	assert(pos);

	LTNode* pre = pos->pre;
	LTNode* next = pos->next;

	pre->next = next;
	next->pre = pre;

	free(pos);
	pos = NULL;
}

//摧毁链表
void ListDestory(LTNode* phead)
{
	assert(phead);

	LTNode* cur = phead->next;
	while (cur != phead)
	{
		LTNode* next = cur->next;
		free(cur);
		cur = next;
	}

	free(phead);
}

3.对其结构的剖析

我们单链表用了二级指针，为什么带头双向循环链表不需要传二级指针呢？

因为我们这里是带头，带头就代表我们不需要创建一个结构体指针指向第一个结点：


我们后面要更改的内容是结构体里面的内容，所以我们只需要传结构体指针，便可以达到目的。

总结

我们学习了这两种链表，相信其他结构的链表也是信手拈来，我们不仅要掌握其逻辑结构，还要掌握其储存结构，才能更好的帮助我们学习数据结构。