文章目录
链表介绍
链表( linked list )是一种物理存储单元上非连续、非顺序的常见的存储结构,用于存储一系列的结(亦可写作 “节” )点。与顺序表不同,链表的每个结点不仅要存储数据元素,还要有指向下一个结点的指针。链表中的结点可以按照次序连接在一起,形成一个链式结构。链表中的第一个结点被称为头结点,最后一个结点被称为尾结点,指向NULL。如图:
链表和顺序表的不同
如下图所示:
\ | 链表 | 顺序表 |
---|---|---|
存储方式 | 使用不相邻的内存块 | 连续的内存空间 |
插入和删除操作时间复杂度 | O(1) | O(n) |
是否支持随机访问 | 否 | 是 |
空间占用比较 | 较大 | 较小 |
扩容缩容操作 | 不需要复制数据 | 需要复制数据 |
综上所述,链表适用于频繁的插入和删除操作,而顺序表适用于频繁的访问操作。选择使用哪种数据结构取决于具体的需求和操作的频率。
有时,我们为了更加方便地对链表进行操作,会在单链表的第一个储存数据的结点位置设置一个头结点,也叫哨兵结点,通常它不存储任何信息。本文介绍的是没有哨兵结点的单链表。
下面开始介绍单链表的相关操作。
一.单链表相关操作(增,删,查,改)
定义结点
typedef int SLTDataType;
typedef struct SListNode
{
SLTDataType data;
struct SListNode* next;
}SListNode;
Ⅰ.头插,尾插,指定位置插入
头插
在头插时,需要更新链表的头指针。为了实现这一操作,可以使用一个二级指针。
一级指针是指针变量,存储了一个地址。二级指针是指向一级指针的指针,即它存储的是一级指针的地址。通过使用二级指针,可以修改一级指针的值。
这里的二级指针 SListNode ** 接受了头指针的地址,在函数内部,解引用过后就可以修改头指针的值,从而实现头插。
//头插
void SListPushFront(SListNode** pplist, SLTDataType x) {
SListNode* newnode = BuySListNode(x); //这个函数的作用是新建结点
newnode->next = *pplist;
*pplist = newnode;
}
尾插
尾插中的二级指针同理。
//尾插
void SListPushBack(SListNode** pplist, SLTDataType x) {
assert(pplist); //保证结构体指针不为空
SListNode* newnode = BuySListNode(x); //这个函数的作用是新建结点
SListNode* tail = *pplist;
if (*pplist == NULL) //1.链表为空
*pplist = newnode;
else { //2.链表不为空,找尾
while (tail->next) {
tail = tail->next;
}
tail->next = newnode;
}
}
指定位置插入
分两种情况,一是在pos之后插入。
1 //在pos之后插入x
2 void SListInsertAfter(SListNode* pos, SLTDataType x) {
3 assert(pos); //保证pos位置有效
4 SListNode* newnode = BuySListNode(x);
5 newnode->next = pos->next;
6 pos->next = newnode;
7 }
这里需要注意的是,5,6两行代码顺序不能交换,如果交换的话,其实结果就等同于 newnode -> next =newnode,这样就失败了。
二是在pos之前插入。
而如果在pos之前插入,又有两种情况。
- pos位置是头结点
- 不是头结点
//在pos之前插入x
void SLTInsert(SListNode** pplist, SListNode* pos, SLTDataType x) {
assert(pplist); //保证结构体指针不为空
assert(pos); //保证pos位置有效
assert(*pplist); //保证原链表有元素
SListNode* newnode = BuySListNode(x);
if (*pplist == pos) { //1.pos位置是头结点,头插
SListPushFront(pplist, x);
}
SListNode* cur = *pplist;
while (cur->next != pos) //2.遍历找pos的前一个位置
{
cur = cur->next;
}
newnode->next = pos;
cur->next = newnode;
}
Ⅱ.头删,尾删,指定位置删除
头删
头删相对简单,只需要一个临时结点即可。
//头删
void SListPopFront(SListNode** pplist) {
assert(*pplist); //保证原链表有元素
SListNode* tmp = *pplist;
*pplist = (*pplist)->next;
free(tmp);
}
尾删
尾删相较头删,要麻烦些许,要分两种情况。
- 链表只有一个元素
- 链表有两个及以上的元素
//尾删
void SListPopBack(SListNode** pplist) {
assert(pplist); //保证结构体指针不为空
assert(*pplist); //保证原链表有元素
SListNode* tail = *pplist;
if ((*pplist)->next == NULL) { //1.链表只有一个元素
free(*pplist);
*pplist = NULL;
}
else { //2.链表有两个及以上的元素
while (tail->next->next) { //找尾
tail = tail->next;
}
free(tail->next);
tail->next = NULL;
}
}
指定位置删除
分两种情况,一是删除pos之后的位置,二是删除pos位置。
而如果是删除pos位置,又有两种情况。
- 位置是头结点
- 不是头结点
//删除pos之后的位置
void SListEraseAfter(SListNode* pos) {
assert(pos&&pos->next); //保证pos位置和pos位置的下一个节点不为NULL
SListNode* tmp = pos->next;
pos->next = pos->next->next;
free(tmp);
tmp = NULL;
}
//删除pos位置
void SLTErase(SListNode** pplist, SListNode* pos) {
assert(pplist && *pplist); //保证结构体指针不为空,原链表有元素
if (*pplist == pos) //1.位置是头结点
SListPopFront(pplist); //头删
SListNode* prev = *pplist; //2.位置不是头结点
while (prev->next != pos) //检查链表是否已排查完
prev = prev->next;
prev->next = pos->next;
free(pos);
pos = NULL;
}
注意,所有的结点在删除后,都需要进行释放置空的操作,否则可能会出现野指针
Ⅲ.查找元素
SListNode* SListFind(SListNode* plist, SLTDataType x) {
assert(plist); //保证结构体不为空
SListNode* cur = plist;
while (cur) { //遍历整个链表,直到NULL
if (cur->data == x)
return cur;
else
cur = cur->next;
}
return NULL;
}
下面是相关函数声明
// 头插
void SListPushFront(SListNode** pplist, SLTDataType x);
// 尾插
void SListPushBack(SListNode** pplist, SLTDataType x);
// 在pos位置之后插入x
void SListInsertAfter(SListNode* pos, SLTDataType x);
// 在pos位置之前插入x
void SLTInsert(SListNode** pplist, SListNode* pos, SLTDataType x);
// 头删
void SListPopFront(SListNode** pplist);
// 尾删
void SListPopBack(SListNode** pplist);
// 删除pos位置之后的值
void SListEraseAfter(SListNode* pos);
// 删除pos位置
void SLTErase(SListNode** pplist, SListNode* pos);
// 查找
SListNode* SListFind(SListNode* plist, SLTDataType x);
二.双向链表
双向链表可以带有哨兵位头结点,也可以不带,本文要介绍的是带哨兵位头结点的双向循环链表。
双向链表,顾名思义,就是一个结点有两个指向的链表,每个节点包含指向前一个节点和后一个节点的指针。如下图所示:
Ⅰ.双向链表和单链表的比较
双向链表和单链表的主要区别是节点的结构不同。单链表的节点(Node)通常包含一个数据元素和一个指向下一个节点的指针,而双向链表的节点除了包含一个数据元素外,还包含一个指向前一个节点的指针。
双向链表相对单链表的优点:
- 可以快速地在任意位置插入或删除节点,而单链表需要去遍历链表。
- 可以方便地实现双向遍历,可以从任意一个节点开始向前或向后遍历整个链表。
然而,双向链表相对于单链表也有一些缺点:
- 由于每个节点需要额外的指针来指向前一个节点,因此占用的内存空间相对要更多一些。
- 在插入或删除节点时,需要同时更新前后节点的指针,操作相对复杂一些。
总的来说,双向链表相对于单链表在插入和删除节点的操作上更加方便快捷,但在内存占用上相对更大。在查找和修改节点的操作上,两者没有太大差异。因此,在具体使用时,需要根据实际需求来选择适合的链表。
Ⅱ.双向链表的相关操作(增,删,查,改)
首先定义结点
typedef int LTDataType;
typedef struct ListNode
{
LTDataType data;
struct ListNode* next;
struct ListNode* prev;
}ListNode;
函数声明
// 双向链表头插
void ListPushFront(ListNode* pHead, LTDataType x);
// 双向链表尾插
void ListPushBack(ListNode* pHead, LTDataType x);
// 双向链表在pos的前面进行插入
void ListInsert(ListNode* pos, LTDataType x);
// 双向链表头删
void ListPopFront(ListNode* pHead);
// 双向链表尾删
void ListPopBack(ListNode* pHead);
// 双向链表删除pos位置的节点
void ListErase(ListNode* pos);
// 双向链表查找
ListNode* ListFind(ListNode* pHead, LTDataType x);
函数实现
插入操作
在增加操作上,单链表需要修改指针来建立节点之间的连接,而双向链表只需要修改两个指针即可。
//头插
void ListPushFront(ListNode* pHead, LTDataType x) {
assert(pHead);
ListNode* newnode = ListCreate(x); //新建一个结点。
ListNode* next = pHead->next;
pHead->next = newnode;
newnode->prev = pHead;
next->prev = newnode;
newnode->next = next;
}
//尾插
void ListPushBack(ListNode* pHead, LTDataType x) {
assert(pHead);
ListNode* tail = pHead->prev;
ListNode* newnode = ListCreate(x);
newnode->next = pHead;
pHead->prev = newnode;
newnode->prev = tail;
tail->next = newnode;
}
//pos位置前面插入
void ListInsert(ListNode* pos, LTDataType x) {
assert(pos);
ListNode* newnode = ListCreate(x);
ListNode* posprev = pos->prev;
posprev->next = newnode;
newnode->prev = posprev;
newnode->next = pos;
pos->prev = newnode;
}
删除操作
删除操作中,单链表需要遍历找到待删除节点的前一个节点来修改指针,而双向链表仍只需要修改两个指针即可。
//头删
void ListPopFront(ListNode* pHead) {
assert(pHead);
assert(pHead->next != pHead);
ListNode* next = pHead->next;
ListNode* next2 = next->next;
pHead->next = next2;
next2->prev = pHead;
free(next);
}
//尾删
void ListPopBack(ListNode* pHead) {
assert(pHead);
assert(pHead->next != pHead);
ListNode* tail = pHead->prev;
tail->prev->next = pHead;
pHead->prev = tail->prev;
free(tail);
}
//指定位置删除
void ListErase(ListNode* pos) {
assert(pos);
pos->prev->next = pos->next;
pos->next->prev = pos->prev;
free(pos);
}
查找pos位置
而在查找操作上,单链表和双向链表没有本质上的区别,都需要从头节点开始遍历直到找到目标节点。
ListNode* ListFind(ListNode* pHead, LTDataType x) {
assert(pHead);
ListNode* cur = pHead->next;
while (cur != pHead) {
if (cur->data == x)
return cur;
else
cur = cur->next;
}
return NULL;
}