学习完链表之后,我们可以清楚的发现,单链表和双向链表可谓是天壤之别。
我们这里就都用哨兵位的形式来看,就免于传二级指针了。
对于单链表,其最头大的缺陷就是,在进行尾插、尾删的时候,需要遍历单链表,此时,时间复杂度就是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);
}
这就是全部的双向链表的增删查改。
那为什么有这么简单的双向带头循环链表,我们还要学习单链表呢,我们都知道,学习得一步一个脚印,并且在栈和队列中,单链表也发挥了不错的作用,因此,各有利弊,我们在学习生活中,要灵活应用。