文章目录
- 前言
- 一、单链表与双向链表
- 二、接口实现 - 带头双向循环链表
- 0. 声明
- 1. 创建新节点
- 2. 创建并初始化
- 3. 销毁
- 4. 打印
- 5. 头插
- 6. 头删
- 7. 尾插
- 8. 尾删
- 9. 查找
- 10. pos位置前插入
- 11.删除pos位置
- 1. 利用Insert实现头插
- 2. 利用Insert实现尾插
- 3. 利用Erase实现头删
- 4. 利用Erase实现尾删
- 三、链表与顺序表
- 总结
前言
文章细分了各个知识点,可在目录中快速跳转。
手机端用户在查看代码块时建议点击代码右上角放大查看,每一段代码均有完整注释。画图很重要,学会作图才能理解其中的核心思想,代码的实现反而是其次的,要画图,然后看图写代码。本文在讲解时也遵循先配图,再进行代码实现的先后顺序。
一、单链表与双向链表
- 无头单向非循环链表:结构简单,一般不会单独用来存数据。实际中更多是作为其他数据结构的子结构,如哈希桶、图的邻接表等等。另外这种结构在笔试面试中出现很多。
- 带头双向循环链表:结构最复杂,一般用在单独存储数据。实际中使用的链表数据结构,都是带头双向循环链表。另外这个结构虽然结构复杂,但是使用代码实现以后会发现结构会带来很多优势,实现反而简单了,下面我们就来实现。
二、接口实现 - 带头双向循环链表
typedef int ListDataType; //注释1
typedef struct ListNode
{
ListDataType val;
struct ListNode* prev;
struct ListNode* next;
}LTNode; //注释2
双向循环链表的节点内拥有两个指针,一个指向前一个节点,一个指向后一个节点
注释:
- 由于后期我们可能会改变链表存储数据的类型,而一但更改,我们需要对每一个调用该类型的地方进行修改,十分麻烦,使用typedef对数据的类型进行重命名,这样以后要更换类型只需要更改此处就可以达到全文替换的目的。
- 重命名简便后续输入,注意我们为什么不直接命名简便一点呢?每个命名都是基于英文单词的释义,这样可以增加在多人协作,以及后续维护代码时的可读性。
LTNode* ListCreate(ListDataType x)
{
LTNode* newnode = (LTNode*)malloc(sizeof(LTNode));
if (newnode == NULL)
{
perror("malloc fail");
exit(-1);
}
newnode->val = x;
newnode->next = NULL;
newnode->prev = NULL;
return newnode;
}
LTNode* ListInit()
{
LTNode* phead = ListCreate(-1); //哨兵位的val值随意赋一个即可
phead->next = phead;
phead->prev = phead;
return phead;
}
哨兵位: 我们创建时,首先开辟一个哨兵点,随意赋值即可,因为哨兵位的作用就是使链表始终有一个节点方便指向,不需要它存放数据。
void ListDestory(LTNode* phead)
{
assert(phead);
LTNode* cur = phead;
LTNode* next = phead->next;
while (cur->next != phead)
{
free(cur); //free可以置空也可以不置空
cur = next;
next = next->next;
}
}
free后要不要置空:如果指针是在接口函数(局部函数)中创建的,可以不置空,因为函数结束会自动销毁所有局部变量,作为养成一个好习惯,我们可以置空,置空一定没有错。
void ListPrint(LTNode* phead)
{
assert(phead);
printf("哨兵位<=>");
LTNode* cur = phead->next;
while (cur != phead) //注释1
{
printf("%d<=>", cur->val);
cur = cur->next;
}
}
注释:
- 也可以写成
cur->next != head
, 但这样如果我们赋值cur的时候直接赋值成phed(哨兵位)时,这种写法会访问到哨兵位的节点值,有可能乍看一眼发现不了,这是我们不希望的。
而使用前种写法,我们在打印时就会发现什么都没打印,就会去寻找问题。
- 方法1
void ListPushFront(LTNode* phead, ListDataType x)
{
assert(phead);
LTNode* newnode = ListCreate(x);
LTNode* first = phead->next;
newnode->next = first;
first->prev = newnode;
newnode->prev = phead;
phead->next = newnode;
}
- 方法2
//要考虑链接的先后顺序
void ListPushFront2(LTNode* phead, ListDataType x)
{
assert(phead);
LTNode* newnode = ListCreate(x);
newnode->next = phead->next;
phead->next->prev = newnode;
phead->next = newnode;
newnode->prev = phead;
}
这里我们提供两种写法,对于后面的接口函数也是可以分成两种写法:
- 一种是多维护一些指针,这样就不用考虑链接的先后顺序,非常方便。
- 一种是不用指针,可以极致节省空间,但需要考虑链接的先后顺序,但对于99%的情况,完全没有必要,只有在嵌入式,单片机这种内存极小的环境下才需要考虑。
void ListPopFront(LTNode* phead)
{
assert(phead);
LTNode* first = phead->next;
LTNode* second = first->next;
phead->next = second;
second->prev = phead;
free(first);
first = NULL;
}
void ListPushBack(LTNode* phead, ListDataType x)
{
assert(phead);
LTNode* newnode = ListCreate(x);
LTNode* tail = phead->prev;
newnode->prev = tail;
tail->next = newnode;
phead->prev = newnode;
newnode->next = phead;
}
void ListPopBack(LTNode* phead)
{
assert(phead);
LTNode* tail = phead->prev;
LTNode* tailprev = tail->prev;
tailprev->next = phead;
phead->prev = tailprev;
free(tail);
tail = NULL;
}
LTNode* ListFind(LTNode* phead, ListDataType x)
{
assert(phead);
LTNode* cur = phead->next;
while (cur != phead)
{
if (cur->val)
return cur;
cur = cur->next;
}
return NULL;
}
void ListInsert(LTNode* pos, ListDataType x)
{
assert(pos);
LTNode* newnode = ListCreate(x);
LTNode* posprev = pos->prev;
posprev->next = newnode;
newnode->prev = posprev;
newnode->next = pos;
pos->prev = newnode;
}
void ListErase(LTNode* pos)
{
LTNode* posprev = pos->prev;
LTNode* posnext = pos->next;
posprev->next = posnext;
posnext->prev = posprev;
free(pos);
pos = NULL;
}
void ListPushFront(LTNode* phead, ListDataType x)
{
assert(phead);
//ListInsert(pHead->next, x);
}
void ListPushBack(LTNode* phead, ListDataType x)
{
assert(phead);
//ListInsert(pHead, x);
}
void ListPopFront(LTNode* phead)
{
assert(phead);
//ListErase(pHead->next);
}
void ListPopBack(LTNode* phead)
{
assert(phead);
//ListErase(pHead->prev);
}
三、链表与顺序表
- 链表(双向)
优势:
- 任意位置插入删除时间复杂度都是O(1);【已知位置的地址前提下】
- 按需申请释放,合理利用空间,不存在浪费
问题:
- 下标随机访问不方便,时间复杂度为O(N)
- 顺序表
优势:
- 支持随机的下标访问,复杂度为O(1),适合大规模排序
问题:
- 头部或中间删除效率低,需要挪动元素,复杂度为O(N)
- 空间不够需要扩容,扩容有一定的消耗,且可能造成空间浪费
- 只适合尾插尾删