【数据结构之单链表】
数据结构学习笔记---003
- 数据结构之单链表
-
- 1、什么是单链表?
-
- 1.1、概念及结构
- 2、单链表接口的实现
-
- 2.1、单链表的SList.h
-
- 2.1.1、定义单链表的结点存储结构
- 2.1.2、声明单链表各个接口的函数
- 2.2、单链表的SList.c
-
- 2.2.1、遍历打印链表
- 2.2.2、销毁单链表
- 2.2.3、打印单链表元素
- 2.2.4、单链表的基本操作
- 3.3、单链表的main.c
-
- 3.3.1、TestSL1()
- 3.3.2、TestSL2()
- 4、单链表巩固练习
-
- 4.1、单链表巩固练习题01 --- 求链表的中间节点
- 4.2、单链表巩固练习题02 --- 移除链表元素
- 4.3、单链表巩固练习题03 --- 链表分割
- 5、单链表总结
数据结构之单链表
前言：
前篇学习了 数据结构的顺序表 那么这篇继续学习数据结构线性表的第二种存储方法，链式存储的单链表。
/知识点汇总/
1、什么是单链表?
1.1、概念及结构
概念：单链表是一种物理存储结构上非连续、非顺序的存储结构，但链表在逻辑上是连续的，顺序的，而数据元素的逻辑顺序是通过链表中的指针连接次序实现的。
由于顺序表的插入删除操作需要移动大量的元素，影响了运行效率，因此引入了线性表的链式存储——单链表。
单链表通过一组任意的存储单元来存储线性表中的数据元素，不需要使用地址连续的存储单元，因此它不要求在逻辑上相邻的两个元素在物理位置上也相邻。
单链表（Singly Linked List）是一种常用的数据结构，它由若干个节点组成，每个节点包含两部分：数据域和指针域。
数据域用于存储数据，而指针域则用于指向下一个节点的地址。 单链表中每个节点只有一个指针域，指向下一个节点，最后一个节点的指针域指向NULL，表示链表的结尾。
2、单链表接口的实现
在实际应用中，单链表的存储思想就是用指针表示各结点之间的逻辑关系。 本质就是掌握好结点间的链式处理。
然后与前篇学的顺序表不同，就不存在扩容的问题了，但仍然需要注意及时释放动态开辟的内存空间等问题。
实现过程继续采用阶段性测试，既方便调试也方便及时解决问题。
另外单链表又分为带头结点和不带头结点的方式，这里用不带头的进行编写，具体可根据实际符合的应用场景决定。
2.1、单链表的SList.h
2.1.1、定义单链表的结点存储结构
因为是采用的多种类型的数据，所以适用于结构体类型。然后知道了需要一个数据域和指针域，所以定义结构体如下所示：
//定义单链表的动态存储
typedef int SLNDataType;//这里的重命名主要作用是，不能保证每次使用都是整型，所以只需要改这里为其它类型更健壮和便利
//Single List
typedef struct SLNode //定义单链表结点类型为结构体类型包括数据域和指针域
{
SLNDataType val; //结点数据域
struct SLNode* next; //结点指针域，存放下一个结点的地址
}SLNode;
2.1.2、声明单链表各个接口的函数
//遍历打印链表
void SLPrint(SLNode* pphead);
//尾插
void SLTPushBack(SLNode** pphead, SLNDataType x);
//头插
void SLTPushFront(SLNode** pphead, SLNDataType x);
//尾删
void SLTPopBack(SLNode** pphead);
//头删
void SLTPopFront(SLNode** pphead);
//查找
SLNode* SLTFind(SLNode* phead, SLNDataType x);
//pphaed = NULL ,错误
//*pphead = NULL，空表
//(*pphead)->next = NULL，一个结点
//在pos位置的前面插入
void SLTInsert(SLNode** pphead,SLNode* pos, SLNDataType x);
//删除pos的位置结点
void SLTErase(SLNode** pphead, SLNode* pos);
//在pos的位置之后的操作，就不存在头插头删的情况，参数就不用传plist了
//在pos的位置之后插入
void SLTInsertAfter(SLNode* pos, SLNDataType x);
//在pos的位置之后删除
void SLTEraseAfter(SLNode* pos);
//销毁单链表
void SLTDestory(SLNode** pphead);
2.2、单链表的SList.c
主要还是要完成 SList.h 接口对应的 .c 功能函数。
有了前篇的意识和基础，对于单链表的初始化可以有但没必要，因为不带头结点本身不用就是空表，那么就体现在后面建立结点函数的写法中对初始化的处理了。但为了对比和理解，把带头结点的常规写法也写一下，但后面继续以不带头的结点写。
初始化单链表(带头结点)：
Node* InitList()
{
Node* first = (Node*)malloc(sizeof(Node)); //生成头结点
first->next = NULL; //头结点的指针域置空
return first;
}
2.2.1、遍历打印链表
为了打印单链表的元素，这里需要像顺序表那样遍历，所以引用一个工作指针，依次访问指针域打印各个结点的数据域中元素。工作指针的本质是读数据域而不作更改，防止写动数据等问题。
//遍历打印链表
void SLPrint(SLNode* phead)
{
SLNode* cur = phead;//定义工作指针，防止更改了phead的地址
while (cur != NULL)
{
printf("%d->", cur->val);//读数据域
cur = cur->next; //偏移指针域
}
printf("NULL\n");
}
2.2.2、销毁单链表
为了避免忘记销毁开辟的动态内存空间。所以这里使用动态存储方法，那么通常把初始化和销毁一块就写出来了。
//顺序表的销毁
void SLDestory(SL* ps1)
{
//暴力检查
assert(ps1);//一定不能为空
if (ps1->a != NULL)
{
free(ps1->a);
ps1->a = NULL;
ps1->size = 0;
ps1->capacity = 0;
}
}
2.2.3、打印单链表元素
为了直观的体现数据元素是否成功操作，所以接着写出打印接口函数。
//打印顺序表
void SLPrint(SL* ps1)
{
//暴力检查
assert(ps1);//一定不能为空
for (int i = 0; i < ps1->size; i++)
{
printf("%d ", ps1->a[i]);
}
printf("\n");
}
2.2.4、单链表的基本操作
完成了上述函数的功能，那么就可以实现单链表的基本操作了。插入和删除以及查找（无非就是增删改查）。
头插和头删；尾插和尾删。
其次，对于开辟新结点的操作多个函数都涉及到，所以可以封装成单独的CreateNode函数，如下所示：
//开辟新结点，且next置空
SLNode* CreateNode(SLNDataType x)
{
SLNode* newnode = (SLNode*)malloc(sizeof(SLNode));
if (newnode == NULL)
{
perror("malloc fail");
//return;
exit(-1);
}
newnode->val = x;
newnode->next = NULL;
return newnode;
}
尾插、头插、尾删、头删的操作，需要注意一下，判空和空表的情况。
//尾插
void SLTPushBack(SLNode** pphead, SLNDataType x)
{
assert(pphead);
//空结点的处理
SLNode* newnode = CreateNode(x);
if (*pphead == NULL)
{
*pphead = newnode;
}
else
{
//找尾（链表不为空，只需要下面的部分，但尽可能的健壮代码，所以需要考虑链表为空的情况）
SLNode* tail = *pphead;
//while (tail != NULL)，容易掉的坑，这样写画图很清楚的看到，链表并没有链接起来；而且除了作用域tail销毁，尾结点会存在内存泄漏的问题
while (tail->next != NULL)
{
tail = tail->next;
}
//因为多个函数都需要开辟新节点，所以直接封装为函数
//而且不能直接SLNode* newNode：来定义结构体来开辟，因为这里只能作用域为局部变量，所以需要malloc才行。
//SLNode* newNode = (SListNode*)malloc(sizeof(SLNode));
//SLNode* newnode = CreateNode(x);已放开头
tail->next = newnode;
}
}
//头插
void SLTPushFront(SLNode** pphead, SLNDataType x)
{
assert(pphead);
SLNode* newnode = CreateNode(x);
newnode->next = *pphead;
*pphead = newnode;
}
//尾删
void SLTPopBack(SLNode** pphead)
{
//注意pphead一定不能为空，所以需要检查
assert(*pphead);
assert(pphead);
//区分一个结点和多个结点
//这两句的位置不同，对应的写法不同
/*
SLNode* tail = *pphead;
//Node* prev = *pphead;//错误，初始化为*phead时，如果首结点被free时，那么prev就会成为野指针。
SLNode* prev = NULL;
if (tail->next == NULL)//一个节点
{
free(tail);
tail = NULL;
}
*/
if ((*pphead)->next == NULL)//一个节点
{
free(*pphead);
*pphead = NULL;
}
else//找尾
{
//这两句的位置可以写这儿
SLNode* tail = *pphead;
//Node* prev = *pphead;//错误，初始化为*phead时，如果首结点被free时，那么prev就会成为野指针。
SLNode* prev = NULL;
while (tail->next != NULL)
{
/*tail = tail->next;
prev = tail;*/
//错误，注意顺序是不可以交换的，因为当tail到空时，还赋给prev就导致为野指针了
prev = tail;
tail = tail->next;
}
free(tail);
tail = NULL;
prev->next = NULL;
//一种简化写法
/*
SLNode* tail = *pphead;
while (tail->next->next != NULL)
{
tail = tail->next;
}
free(tail->next);//释放的是指针指向的内存空间，而不是指针本身
tail->next = NULL;
*/
}
}
//头删
void SLTPopFront(SLNode** pphead)
{
assert(*pphead);
assert(pphead);
//if ((*pphead)->next == NULL)//一个节点
//{
// free(*pphead);
// *pphead = NULL;
//}
//一个以及以上结点都能处理
//方法1：
//SLNode* tail = *pphead;
//tail = tail->next;
//free(*pphead);
//*pphead = tail;
//方法2：
//SLNode* tail = *pphead;
//*pphead = (*pphead)->next;
//free(tail);
//方法3：
SLNode* tmp = (*pphead)->next;;
free(*pphead);//注意顺序不能交换
*pphead = tmp;
}
查找、在pos位置的前面插入、删除pos的位置、在pos的位置之后插入和在pos的位置之后删除操作。
//查找
SLNode* SLTFind(SLNode* phead, SLNDataType x)
{
assert(phead);
SLNode* cur = phead;//定义工作指针，防止更改了phead的地址
while (cur != NULL)
{
if (cur->val == x)
return cur;
cur = cur->next; //偏移指针域
}
return NULL;
}
//在pos位置的前面插入
void SLTInsert(SLNode** pphead, SLNode* pos, SLNDataType x)
{
/*assert(pphead);
assert(*pphead);
assert(pos);*///这种检查严格限定了pos一定为链表里的有效节点
assert(pphead);
assert((!pos && !(*pphead)) ||(pos && *pphead));//要么都是空，要么都不是空
//对空处理
if (*pphead == pos)
{
//调用头插
SLTPushFront(pphead, x);
}
else//找插入结点的前一个结点
{
SLNode* prev = *pphead;
while (prev->next != pos)
{
prev = prev->next;
}
SLNode* newnode = CreateNode(x);
prev->next = newnode;
newnode->next = pos;
}
}
//删除pos的位置
void SLTErase(SLNode** pphead, SLNode* pos)
{
assert(pphead);
assert(*pphead);
assert(pos);
//头结点梳理
if ((*pphead)->next == NULL)
{
//调用头删
SLTPopFront(pphead);
}
else
{
SLNode* prev = *pphead;
if (prev == pos)
{
//调用头删
SLTPopFront(pphead);
}
else
{
while (prev->next != pos)
{
prev = prev->next;
}
prev->next = pos->next;
free(pos);
pos = NULL;
}
}
}
//在pos的位置之后插入
void SLTInsertAfter(SLNode* pos, SLNDataType x)
{
assert(pos);
SLNode* newnode = CreateNode(x);
//经典错误，单链表断开，自己指向了自己
/*pos->next = newnode;
newnode->next = pos->next;*/
newnode->next = pos->next;
pos->next = newnode;
}
//扩展：只给pos位置，如何完成想在pos之前插入呢？
//只需要在pos后面插入，交换pos的结点值即可
//在pos的位置之后删除
void SLTEraseAfter(SLNode* pos)
{
assert(pos);
assert(pos->next);//因为当只有一个结点时，cur=pos->next,为空，所以对pos->next访问就非法访问了。
SLNode* cur = pos->next;
pos->next = cur->next;
free(cur);
cur = NULL;
}
3.3、单链表的main.c
简单的写几个测试应用，目的是检测各个接口函数是否满足需求，是否存在一些bug。
3.3.1、TestSL1()
主要检测尾插、头插、打印和销毁接口函数，以及参数的传址调用和传值调用。
#include "SList.h"
//测试1：
void TestSLT1()
{
SLNode* plist = NULL;
//SLTPushBack(plist, 1);//传参为SLNode*,要想实现操作，还得使用二级指针，所以这里必须传地址 ==>不然phead只是plist的临时拷贝
SLTPushBack(&plist, 1);
SLTPushBack(&plist, 2);
SLTPushBack(&plist, 3);
SLTPushBack(&plist, 4);//尾插
SLPrint(plist);//打印
SLTPopBack(&plist);//尾删
SLPrint(plist);
SLTPushFront(&plist, 5);//头插
SLPrint(plist);
SLTPushFront(&plist, 6);//头插
SLPrint(plist);
SLTPopBack(&plist);//尾删
SLPrint(plist);
SLTPopBack(&plist);//尾删
SLPrint(plist);
}
int main()
{
TestSLT1();
//TestSLT2();
//TestSLT3();
//TestSLT4();
//TestSLT5();
return 0;
}
测试效果展示：
3.3.2、TestSL2()
主要检测接口函数是否满足需求，并深刻认识指针、二级指针的应用。
#include "Seqlist.h"
//测试二：
void TestSLT2()
{
SLNode* plist = NULL;
//SLTPushBack(plist, 1);//传参为SLNode*,要想实现操作，还得使用二级指针，所以这里必须传地址 ==>不然phead只是plist的临时拷贝
SLTPushBack(&plist, 1);
SLTPushBack(&plist, 2);
SLTPushBack(&plist, 3);
SLTPushBack(&plist, 4);//尾插
SLPrint(plist);//打印
SLTPopFront(&plist);
SLPrint(plist);
}
int main()
{
//TestSL1();
TestSL2();
//TestSL3();
//TestSL4();
//TestSL5();
//TestSL6();
//TestSL7();
return 0;
}
效果展示：
4、单链表巩固练习
4.1、单链表巩固练习题01 — 求链表的中间节点
求链表的中间节点 — 经典快慢指针
#include "SList.h"
//定义单链表的结构体类型
struct ListNode
{
int val;
struct ListNode* next;
};
struct ListNode* middleNode(struct ListNode* head)
{
struct ListNode* slow = head;
struct ListNode* fast = head;
while (fast && fast->next)
{
slow = slow->next;
fast = fast->next->next;
}
return slow;
}
int main()
{
SLNode* plist = NULL;
//SLTPushBack(plist, 1);//传参为SLNode*,要想实现操作，还得使用二级指针，所以这里必须传地址 ==>不然phead只是plist的临时拷贝
SLTPushBack(&plist, 1);
SLTPushBack(&plist, 2);
SLTPushBack(&plist, 3);
SLTPushBack(&plist, 4);//尾插
SLPrint(plist);//打印
struct ListNode* pos = middleNode(plist);
printf("pos = %d\n", pos->val);
return 0;
}
4.2、单链表巩固练习题02 — 移除链表元素
移除链表元素 – 返回新的头结点
方法1：遍历删除
#include "SList.h"
//定义单链表的结构体类型
struct ListNode
{
int val;
struct ListNode* next;
};
struct ListNode* removeELements(struct ListNode* head, int val)
{
struct ListNode* prev = NULL;//prev的作用，是在于删除对应结点后，能找到next断开之后再链接
struct ListNode* cur = head;
while (cur)
{
if (cur->val == val)
{
struct ListNode* tmp = cur->next;
free(cur);
if (prev)//必须判断首节点是否val,被free后，可能为空
prev->next = tmp;
else//否则,新的头结点更新
head = tmp;
cur = tmp;
}
else
{
prev = cur;
cur = cur->next;
}
}
return head;
}
int main()
{
struct ListNode* n1 = (struct ListNode*)malloc(sizeof(struct ListNode));
struct ListNode* n2 = (struct ListNode*)malloc(sizeof(struct ListNode));
struct ListNode* n3 = (struct ListNode*)malloc(sizeof(struct ListNode));
struct ListNode* n4 = (struct ListNode*)malloc(sizeof(struct ListNode));
n1->val = 7;
n2->val = 7;
n3->val = 2;
n4->val = 3;
n1->next = n2;
n2->next = n3;
n3->next = n4;
n4->next = NULL;
struct ListNode* head = removeELements(n1, 7);
SLPrint(head);
return 0;
}
方法2：遍历把不是val的结点链接到新链表，添加尾指针
#include "SList.h"
//定义单链表的结构体类型
struct ListNode
{
int val;
struct ListNode* next;
};
//打印链表
void SLPrint1(struct ListNode* phead)
{
struct ListNode* cur = phead;//定义工作指针，防止更改了phead的地址
while (cur != NULL)
{
printf("%d->", cur->val);//读结点域
cur = cur->next; //偏移指针域
}
printf("NULL\n");
}
struct ListNode* removeELements(struct ListNode* head, int val)
{
struct ListNode* newnode = NULL;
struct ListNode* tail = NULL;
struct ListNode* cur = head;
while (cur)
{
//如果不是val把结点拿到新链表(新链表为空)
if (cur->val != val)
{
//尾插：两种情况
if (tail == NULL)
{
newnode = tail = cur;
}
else
{
tail->next = cur;
tail = tail->next;
}
cur = cur->next;
}
else
{
struct ListNode* tmp = cur;
cur = cur->next;
free(tmp);
}
}
if(tail)//注意最后尾节点的判空，防止野指针，同时判空处理空表
tail->next = NULL;
head = newnode;
return head;
}
int main()
{
struct ListNode* n1 = (struct ListNode*)malloc(sizeof(struct ListNode));
struct ListNode* n2 = (struct ListNode*)malloc(sizeof(struct ListNode));
struct ListNode* n3 = (struct ListNode*)malloc(sizeof(struct ListNode));
struct ListNode* n4 = (struct ListNode*)malloc(sizeof(struct ListNode));
n1->val = 7;
n2->val = 7;
n3->val = 2;
n4->val = 3;
n1->next = n2;
n2->next = n3;
n3->next = n4;
n4->next = NULL;
struct ListNode* head = removeELements(n1, 7);
SLPrint1(head);
return 0;
}
方法3：添加哨兵位头结点
哨兵位的头结点，不存储有效数据置NULL
#include "SList.h"
//定义单链表的结构体类型
struct ListNode
{
int val;
struct ListNode* next;
};
//打印链表
void SLPrint1(struct ListNode* phead)
{
struct ListNode* cur = phead;//定义工作指针，防止更改了phead的地址
while (cur != NULL)
{
printf("%d->", cur->val);//读结点域
cur = cur->next; //偏移指针域
}
printf("NULL\n");
}
struct ListNode* removeELements(struct ListNode* head, int val)
{
struct ListNode* newnode = NULL;
struct ListNode* tail = NULL;
struct ListNode* cur = head;
//添加哨兵位
newnode = tail = (struct ListNode*)malloc(sizeof(struct ListNode));
while (cur)
{
//如果不是val把结点拿到新链表(新链表为空)
if (cur->val != val)
{
//尾插：两种情况
tail->next = cur;
tail = tail->next;
cur = cur->next;
}
else
{
struct ListNode* tmp = cur;
cur = cur->next;
free(tmp);
}
}
//哨兵位方法前面简化，而这里就需要处理
tail->next = NULL;
struct ListNode* tmp = newnode;
newnode = newnode->next;
free(tmp);
head = newnode;//头结点next为首节点符合题目要求
return head;
}
int main()
{
struct ListNode* n1 = (struct ListNode*)malloc(sizeof(struct ListNode));
struct ListNode* n2 = (struct ListNode*)malloc(sizeof(struct ListNode));
struct ListNode* n3 = (struct ListNode*)malloc(sizeof(struct ListNode));
struct ListNode* n4 = (struct ListNode*)malloc(sizeof(struct ListNode));
n1->val = 7;
n2->val = 7;
n3->val = 2;
n4->val = 3;
n1->next = n2;
n2->next = n3;
n3->next = n4;
n4->next = NULL;
struct ListNode* head = removeELements(n1, 7);
SLPrint1(head);
return 0;
}
4.3、单链表巩固练习题03 — 链表分割
链表分割 — 返回重新排列后的头指针,相对顺序不变
3 6 1 8 4 6 9 — val=5分割
3 1 4 (5)6 8 6 9
思路1：不带哨兵位，比较val小的放一个链表，大于等于val的放一个链表，再合并两个链表，同时注意判断两边链表为空的情况，即全比val大或者小的处理，所以相对于带头结点的操作就比较复杂。
思路2：带2个哨兵位，直接比较后，执行相应的尾插操作即可，最后合并。
建议采用带头结点的方法，更好处理这题
#include "SList.h"
//#include 5、单链表总结
主要有以下两点：
与顺序表不同，单链表的元素不是连续存储的，而是通过指针相连形成链式结构。因此，单链表具有以下优缺点。
优点：
支持动态内存分配。由于单链表不需要预先分配一段连续的空间，因此可以根据实际需求动态地申请、释放节点空间，避免浪费内存。
支持高效的插入、删除操作。由于单链表中的节点是通过指针相连的，因此在插入、删除一个节点时，只需要修改其前驱节点或后继节点的指针即可，时间复杂度为O(1)O(1)O(1)。
缺点：
不支持随机访问。由于单链表中的节点不是连续存储的，因此不能像数组一样通过下标来直接访问一个元素，需要从头节点开始遍历整个链表才能访问任意位置的元素。