【数据结构】带头双向循环链表通讯录的实现和复杂链表复制题目分析

一、带头双向循环链表的实现

1.简单介绍

带头双向循环链表看起来复杂但是因为他自身的结构特性，用到一些实际应用层面是有很大优势的。

2.结构体的创建，链表初始化和头结点的创建

结构体的创建（prev指向前一个结点，next指向后一个结点，以此达到双向循环）。

typedef int LTdataType;
typedef struct ListNode
{
	LTdataType data;
	struct ListNode* next;
	struct ListNode* prev;

}LTNode;

链表的初始化+头结点的创建

首先要创建一个一个的结点

LTNode* BuyListNode(LTdataType x)
{
	LTNode* node = (LTNode*)malloc(sizeof(LTNode));
	if (node == NULL)
	{
		perror("malloc fail");
		exit(-1);
	}
	node->data = x;
	node->next = NULL;
	node->prev = NULL;
	return node;
}

初始化时将第一个创建的结点作为头结点，这里需要注意因为是双向循环的，所以由上面的图可知，当只有头结点时，prev和next都应该指向头结点自身。

LTNode* LTIint()
{
	LTNode* phead = BuyListNode(-1);
	phead->next = phead;
	phead->prev = phead;
	return phead;
}

3.头插+头删+尾插+尾删+链表打印

3.1头插

这里考虑一般情况和当只有头结点时的情况

只有头结点时（黑线代表插入前，蓝色代表插入后）

一般情况下插入

这里注意在建立newnode和d1之间的联系时要用一个指针记录d1的位置，不然后面找不到。

void LTPushFront(LTNode* phead, LTdataType x)
{
	LTNode* newnode = BuyListNode(x);
	LTNode* first = phead->next;

	phead->next = newnode;
	newnode->prev = phead;
	newnode->next = first;
	first->prev = newnode;
}

3.2 头删

1.首先要注意是否只剩头结点了，如果是那就不能再删除了
2.同样要注意删除时被删除的结点的两侧的链接问题（是否还能找到两侧的结点）.

void LTPopFront(LTNode* phead)
{
	assert(phead);
	assert(phead->next != phead);//链表为空
	LTNode* first = phead->next;
	LTNode* second = first->next;

	free(first);

	phead->next = second;
	second->prev = phead;
}

3.3 尾插

尾插因为要改变链表尾部所以需要找到插入newnode前最后一个结点（也就是phead->prev）。

void LTPushBack(LTNode* phead,LTdataType x)
{
	assert(phead);
	LTNode* newnode = BuyListNode(x);
	LTNode* tail = phead->prev;

	tail->next = newnode;
	newnode->prev = tail;

	newnode->next = phead;
	phead->prev = newnode;
}

3.4 尾删

与尾插一样，不过这里不仅要找到最后一个结点，还要找到倒数第二个结点，因为此节点要在最后一个结点被删除时，与头结点产生连接。
同样prev->next不为NULL

void LTPopBack(LTNode* phead)
{
	assert(phead);
	assert(phead->next != phead);

	LTNode* tail = phead->prev;//找到最后一个结点

	LTNode* tailPrev = tail->prev;//找到倒数第二个结点
	phead->prev = tail->prev;
	tailPrev->next = phead;

	free(tail);
}

3.5 链表打印

void LTPrint(LTNode* phead)
{
	assert(phead);
	LTNode* cur = phead->next;

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

注意while循环结束的条件，因为是循环的，由上面的图可知，在结束最后一次cur=cur->next，cur就指向了phead。

4.查找结点+在pos之前插入+删除pos位置

4.1 查找结点

遍历链表，找到了返回结点地址，找不到返回空（在后面的在pos之前插入和删除pos都需要此函数来寻找pos的位置）

LTNode* LTFind(LTNode* phead, LTdataType x)
{
	assert(phead);
	LTNode *cur = phead->next;
	while (cur!=phead)
	{
		if (cur->data == x)
		{
			return cur;
		}
		cur = cur->next;
	}
	return NULL;
}

4.2 在pos之前插入x

void LTInsert(LTNode* pos, LTdataType x)
{
	assert(pos);
	LTNode* prev = pos->prev;
	LTNode* newnode = BuyListNode(7);
	prev->next = newnode;
	newnode->prev = prev;

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

在这里我们想一想
如果pos的位置在第一个结点上，那不就相当于头插了吗。
如果pos的位置在phead头结点上，那不就相当于尾插了吗。
所以头插和尾插可以改成以下的形式。

头插

void LTPushFront(LTNode* phead, LTdataType x)
{
	/*LTNode* newnode = BuyListNode(x);
	LTNode* first = phead->next;

	phead->next = newnode;
	newnode->prev = phead;
	newnode->next = first;
	first->prev = newnode;*/

	LTInsert(phead->next, x);
}

尾插

void LTPushBack(LTNode* phead,LTdataType x)
{
	assert(phead);
	/*LTNode* newnode = BuyListNode(x);
	LTNode* tail = phead->prev;

	tail->next = newnode;
	newnode->prev = tail;

	newnode->next = phead;
	phead->prev = newnode;*/

	LTInsert(phead, x);
}

4.3删除pos位置

void LTErase(LTNode* pos, LTdataType x)
{
	assert(pos);
	LTNode* prev = pos->prev;
	LTNode* next = pos->next;

	free(pos);

	prev->next = next;
	next->prev = prev;
}

从这里我们也可以看出，
如果pos位置在第一个结点处（phead->next），那就是头删
如果pos位置在最后一个结点处（phead->prev）,就是尾删

头删

void LTPopFront(LTNode* phead)
{
	assert(phead);
	assert(phead->next != phead);//链表为空
	/*LTNode* first = phead->next;
	LTNode* second = first->next;

	free(first);

	phead->next = second;
	second->prev = phead;*/

	LTErase(phead->next);
}

尾删

void LTPopBack(LTNode* phead)
{
	assert(phead);
	assert(phead->next != phead);

	/*LTNode* tail = phead->prev;

	LTNode* tailPrev = tail->prev;
	phead->prev = tail->prev;
	tailPrev->next = phead;

	free(tail);*/

	LTErase(phead->prev);

}

5.释放链表空间（销毁通讯录）

void LTDestroy(LTNode* phead)
{
	assert(phead);

	LTNode* cur = phead->next;

	while (cur != phead)
	{
		LTNode* next = cur->next;
		free(cur);
		cur = next;
	}
	//释放头结点
	free(phead);
	phead==NULL；
}

讲完了知识点，附带一道题练练手。

二、复杂链表复制

这样一个链表，我们要复制它。假设我们已经建好了这样一个单链表

我们想到此时第一个存储7的结点的random指向1（本题难点也是找到每个结点的random指向的另一个结点是谁），**将两个链表合起来看，我们发现这也是第一个链表中存储7的结点的random指向的地方。**因为两个链表本来就是拷贝的关系，是一样的，我们不妨把他们加在一起。(这就像从1数到100，将它与100到1相加,最后的结果除以二，利用两两相加等于101的规律），在这里我们也是利用其实下面的每个结点的random所指向的地方也是上面的相同的结点的random所指向的地方。
所以第一步我们将这两个链表合起来（这里直接按顺序）。

struct Node* cur = head;
	while (cur)
	{
		struct Node* next = cur->next;
		struct Node* copy = (struct Node*)malloc(sizeof(struct Node));
		copy->val=cur->val;
		//插入链接
		cur->next = copy;
		copy->next = next;
		
		cur = next;
	}

据我们刚刚的思路，copy的random所指向的地方也就是cur的random所指向的地方，这里有两种情况一种是当cur为第一个结点时（此时random指向null），一种是不是第一个节点是。
我们将这些话翻译成代码就是这样的

cur=head;
while (cur)
	{
	    struct Node*copy=cur->next;
		if (cur->random == NULL)
		{
			copy->random = NULL;
		}
		else
		{
			copy->random = cur->random->next;
		}
		cur=cur->next->next;
	}

好了此时我们其实已经完成了一大半了，因为我们已经找到了copy的链表的每个结点的random所指向的地方，并将他们成功的链接起来。
此时就不是数学上的除二，而是将这两个链表分离以达到“除二”的效果，分离后，我们也拿到了复制后的链表。（分离时需要将原先复制的链表拿下来链接，原本的链表也需要链接好）
以下就是分离的过程：

cur = head;
	struct Node* copyHead = NULL, * copyTail = NULL;
	while (cur)
	{
		struct Node* copy = cur->next;
		struct Node* next = copy->next;

		cur->next=next;
		//尾插
		if (copyTail == NULL)
		{
			copyHead=copyTail= copy;
		}
		else
		{
			copyTail->next = copy;
			copyTail = copyTail->next;
		}
		cur = next;
	}
	return copyHead;