带头双向循环链表的增删查改

学习完链表之后，我们可以清楚的发现，单链表和双向链表可谓是天壤之别。

我们这里就都用哨兵位的形式来看，就免于传二级指针了。

对于单链表，其最头大的缺陷就是，在进行尾插、尾删的时候，需要遍历单链表，此时，时间复杂度就是o(n)。

然而，带头双向循环链表在进行插入删除的时候，并不需要遍历全链表。加下来我们来看看双链表的增删查改。

首先，简单的初始化、销毁、打印就不分析了，参照单链表即可，唯一注意的点是：这个链表是循环的，循环判断的条件与单链表不同。

// 创建返回链表的头结点.
ListNode* ListCreate()
{
	ListNode* NewNode = (ListNode*)malloc(sizeof(ListNode));
	if (NewNode == NULL)
		perror("malloc fail");


	NewNode->next = NewNode;
	NewNode->prev = NewNode;
	NewNode->data = 0;
	return NewNode;
}




// 双向链表销毁
void ListDestory(ListNode* pHead)
{
	assert(pHead->next != pHead);


	ListNode* cur = pHead->next;
	ListNode* del = cur;


	while (cur != pHead)
	{
		cur = cur->next;
		free(del);
		del = cur;
	}
	pHead->next = pHead;
	pHead->prev = pHead;
}






// 双向链表打印
void ListPrint(ListNode* pHead)
{
	assert(pHead->next!=pHead);
	ListNode* cur = pHead->next;




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


}

接下来是头插头删，为什么先说头插头删，因为对于两种类型的链表，时间复杂度相同，只是操作有略微的差异。

这是单链表的：

void SListPushFront(SListNode** pplist, SLTDateType x)
{
	assert(pplist);
	SListNode* phead = *pplist;
	if (phead == NULL)
	{
		*pplist = BuySListNode(x);
	}

	else if (phead->next == NULL)
	{
		phead = BuySListNode(x);
		phead->next = *pplist;
		*pplist = phead;
	}

	else
	{
		while (phead->next)
			phead = phead->next;
		phead = BuySListNode(x);
		phead->next = *pplist;
		*pplist = phead;
	}
}

// 单链表头删
void SListPopFront(SListNode** pplist)
{
	SListNode* phead = *pplist;
	assert(phead != NULL);

	if (phead->next == NULL)
	{
		free(*pplist);
		*pplist = NULL;
	}

	else
	{
		*pplist = (*pplist)->next;
		free(phead);
	}
}

这里我用了二级指针，但是如果带了哨兵位的话，我们就可以直接用一级指针传参了。

然后，这个是双向链表的：

// 双向链表尾删
void ListPopBack(ListNode* pHead)
{
	assert(pHead->prev != pHead);

	ListNode* cur = pHead->prev;
	pHead->prev = cur->prev;
	cur->prev->next = pHead;
	free(cur);
}


// 双向链表头插
void ListPushFront(ListNode* pHead, LTDataType x)
{
	assert(pHead);

	ListNode* NewNode = ListCreate();
	NewNode->data = x;

	pHead->next->prev = NewNode;
	NewNode->next = pHead->next;
	NewNode->prev = pHead;
	pHead->next = NewNode;

}

很明显，判断条件少了，代码长度也变短了，显然是双向链表的类型更容易操作。

接下来我们来看更加显而易见的区别，上代码：

这是单链表的尾插尾删：

void SListPushBack(SListNode** pplist, SLTDateType x)
{
	SListNode* phead = *pplist;
	if (phead == NULL)
	{
		*pplist = BuySListNode(x);
	}

	else if(phead->next==NULL)
		phead->next = BuySListNode(x);

	else
	{
		while (phead->next)
			phead = phead->next;
		phead->next = BuySListNode(x);
	}
}

// 单链表的尾删
void SListPopBack(SListNode** pplist)
{
	assert(pplist != NULL);
	SListNode* phead = *pplist;
	assert(phead != NULL);

	if (phead->next == NULL)
	{
		free(*pplist);
		*pplist = NULL;
	}

接下来，我们再看双向链表的：

// 双向链表尾插
void ListPushBack(ListNode* pHead, LTDataType x)
{
	assert(pHead);

	ListNode* NewNode = ListCreate();
	NewNode->data = x;

	pHead->prev->next = NewNode;
	NewNode->prev = pHead->prev;
	pHead->prev = NewNode;
	NewNode->next = pHead;
	NewNode->data = x;

}


// 双向链表尾删
void ListPopBack(ListNode* pHead)
{
	assert(pHead->prev != pHead);

	ListNode* cur = pHead->prev;
	pHead->prev = cur->prev;
	cur->prev->next = pHead;
	free(cur);
}

可见，双向链表的头尾操作相差无几，但是单链表的尾插尾删明显多了一个遍历单链表的工作，大大增加了时间复杂度。

最后，我们把双向链表的增删查改补充完整：

/ 双向链表查找
ListNode* ListFind(ListNode* pHead, LTDataType x)
{
	assert(pHead->next != pHead);
	ListNode* cur = pHead->next;
	while (cur != pHead)
	{
		if (cur->data == x)
			return cur;
		cur = cur->next;
	}
}

// 双向链表在pos的前面进行插入
void ListInsert(ListNode* pos, LTDataType x)
{
	assert(pos);
	ListNode* NewNode = ListCreate();
	pos->prev->next = NewNode;
	NewNode->prev = pos->prev;
	pos->prev = NewNode;
	NewNode->next = pos;
	NewNode->data = x;
}


// 双向链表删除pos位置的节点
void ListErase(ListNode* pos)
{
	assert(pos);
	pos->prev->next = pos->next;
	pos->next->prev = pos->next;

	free(pos);

}

这就是全部的双向链表的增删查改。

那为什么有这么简单的双向带头循环链表，我们还要学习单链表呢，我们都知道，学习得一步一个脚印，并且在栈和队列中，单链表也发挥了不错的作用，因此，各有利弊，我们在学习生活中，要灵活应用。