前言:本期我们将讨论线性表另外一种存储结构————链式存储结构,相比顺序表互有优劣,我们不能片面的认为链表优势大于顺序表,两种存储方式都应该熟知并掌握。
物理
存储结构上非连续、非顺序
的存储结构。逻辑顺序
是通过链表中的指针链接次序
实现的 。小结:链表是逻辑结构
上类似于顺序表的连续
的结构,但实际物理
结构是不一定连续
存储的。
接下来我们展开说说:
链表实际上是由不同的结点链接
而成的(结点是由结构体
类型来创建而成的)
结点是由数据域data
(存放数据)和指针域next
(存放下一个结点的地址)所组成的
结点一般是在堆
上申请空间的(申请的空间的地址在堆区上是随机分配
的,即空间的地址是随机
的,这也是为什么每个结点的地址不一定连续),因此不能像顺序表进行下标访问
简而言之:
下标
进行随机访问
,而是通过访问每个结点的指针域
(指针域内存储了下一个结点的空间地址),即通过访问下一个结点的地址,去找到下一个结点。指针域
里的地址链接
起来的,其中元素之间的空间地址并不连续,所以不能像顺序表
进行下标访问
,这也是为什么链表的逻辑结构
与物理结构
不同由N
个结点组成的就叫做链表
,在此基础上由一个指针
链接起来的就叫做单链表
,后续还会有双链表…单向不带头链表…等等。
如上图,整个链表的的存取打印必须从头指针
开始进行,头指针表示链表中第一个结点(即第一个数据元素的地址)的存储位置,这里的头指针就是phead/plist
, 由于最后一个数据元素没有直接后续,又为了方便链接新节点,所以链表最后一个结点的指针为“空”(NULL
)。
有了以上对链表的概念后,我们便可以实现它啦~
对于数据结构的接口实现,一般围绕着
增、删、查、改
的内容
typedef int SLTDataType;
typedef struct SListNode
{
SLTDataType data; //存储数据
struct SListNode* next; //指向下一个结点的地址
}SLTNode;
注意:
typedef int SLTDataType;
typedef struct SListNode
{
SLTDataType data;
struct SListNode* next;
//SLTNode* next; //下面这两种写法都是错的哦
//SListNode* next;
}SLTNode,*PSLTNode; //(SLTNode是SListNode的重定义;*PSLTNode是struct SListNode的重定义)
接下来我们实现动态顺序表的各接口函数,此处我们实现的是基础的单向不带头不循环链表
。
思路:像顺序表的空间开辟,与插入函数类似,直接看代码
SLTNode* BuySLTNode(SLTDataType x)
{
SLTNode* newnode = (SLTNode*)malloc(sizeof(SLTNode)); // 动态申请一个空间
if (newnode == NULL)
{
perror("malloc fail");
exit(-1);
}
newnode->data = x; // 将新数据放到结构体的数据域中
newnode->next = NULL;// 链接下一个结点
return newnode;
}
思路:打印这个链表并不需要对链表进行存取,所以形参部分就直接用一级指针就行了。定义一个结构体指针cur
,让cur
指向这个链表的头指针
(也就是指向这个链表的起始位置)。
用cur这个指针去遍历这个数组并打印
单链表结构非常简单,不需要初始化
SLTNode* plist = NULL
这样就表示一个单链表了
思路:新申请一个结点,将新结点的newnode->next
用来存放头指针(pphead)
的地址,再让头指针(pphead)
指向的位置改变为新结点(newnode)
观察下面代码,先思考一下这样创建新结点是否可行?
SLTNode newnode;
显然是不行的,因为是局部变量,出了作用域这个结点就销毁了。
void SListPushFront(SLTNode* phead, SLTDataType x)
{
SLTNode* newnode = BuySLTNode(x); //把新结点申请出来
newnode->next = phead; //让新结点的next指向第一个老结点的phead
phead = newnode; //把新申请的结点的地址再重新放到phead上
}
如果你是按照上面这个方式写代码,那可就要出事了,因为犯了一个经典错误。
打开调试窗口开一下,诶,似乎已经正确插入了呀,别急,打印看一下。
出问题了,怎么打印出NULL了?刚刚不是存进去了吗?
我们结合栈帧的知识讲解一下,不了解栈帧的朋友可以看一看【C语言详解】——函数栈帧的创建与销毁(动图详解)这篇文章哦~
那有朋友就要问了,传参传的不是指针吗,为什么也无效呢?
其实,传指针要解引用的,上面的代码就是没有解引用。
举个例子:
void swapi(int* px, int* py)
{
int tmp = *px;
*px = *py;
*py = tmp;
}
int main()
{
int x = 0, y = 1;
swapi(&x, &y);
int* p1 = &x, *p2 = &y;
swapi(p1, p2);
return 0;
}
注意看动图,好像x,y值变了,再仔细看,诶,好像它俩的地址没变,指向的值倒是变了。可是,我们的任务是交换指针来着,问题就出在这里了。
这时候,就要请出我们的二级指针
了。
void swapptr(int** ppx, int** ppy)
{
int* tmp = *ppx;
*ppx = *ppy;
*ppy = tmp;
}
所以,平时我们传内容,用一级指针就足矣,但我们这次要传指针,就要用到指针的指针,即传二级指针过去,然后二级指针解引用。
小结:要改变谁,就传谁的地址。
正确代码:
void SListPushFront(SLTNode** pphead, SLTDataType x)
{
assert(pphead);
SLTNode* newnode = BuySLTNode(x); //把新结点申请出来
newnode->next = *pphead; //让新结点的next指向第一个老结点的pphead
*pphead = newnode; //把新申请的结点的地址再重新放到pphead上
}
注意:
newnode->next = *pphead;
和
*pphead = newnode;
这两条语句千万不要弄反了,否则就会丢失下一个结点的地址了。
思路:进行尾插第一步先申请一个新结点,之后需要判断链表是否为空
,如果是空直接将新开辟的结点连到头结点pphead即可,如果不为空就用一个指针找到尾结点,然后链接新结点。
在SListPrint
中我们知道,链表有可能为空,那么在SListPushBack
中传过来的pphead
有可能为空吗?
其实,是不可能为空的。
pphead
是plist
的地址,也就意味着plist
为空,但pphead
永远不可能为空,因此记得断言哦~
void SListPushBack(SLTNode** pphead, SLTDataType x)
{
assert(pphead);
SLTNode* newnode = BuySLTNode(x);
// 1、空
// 2、非空
if (*pphead == NULL)
{
*pphead = newnode;
}
else
{
// 找尾
SLTNode* tail = *pphead;
while (tail->next != NULL)
{
tail = tail->next;
}
tail->next = newnode;
}
}
思路:先判断是否为空,不为空则创建一个del
结点,把第一个结点的地址传给它,然后头指针指向下一个结点,free
释放掉del
即可。这种思路也很好的兼顾了只有一个结点
的情况。
void SListPopFront(SLTNode** pphead)
{
assert(pphead);
// 为空不能删
// 温柔的检查
if (*pphead == NULL)
{
return;
}
// 暴力的检查
//assert(*pphead != NULL); //c++库里都是暴力的检查哦~
SLTNode* del = *pphead;
*pphead = (*pphead)->next; //优先级记得加括号
free(del);
del = NULL; //好习惯不写无所谓
}
思路:先判断是否为空,不为空则区分两种情况,一个结点和多个结点,找尾后释放。
首先观察一下下面这段找尾代码可行吗?
void SListPopBack(SLTNode** pphead)
{
assert(pphead);
if (*pphead == NULL)
{
return;
}
if ((*pphead)->next == NULL)
{
free(*pphead);
*pphead = NULL;
}
else
{
// 找尾
SLTNode* tail = *pphead;
while (tail->next != NULL)
{
tail = tail->next;
}
free(tail);
}
}
上面这段代码就是经典的野指针问题。
解决方式就是,需要两个指针,一个向前跑,一个在后面记录上一个结点的地址。
// 找尾
SLTNode* prev = NULL;
SLTNode* tail = *pphead;
while (tail->next != NULL)
{
prev = tail;
tail = tail->next;
}
prev->next = NULL;
free(tail);
tail = NULL;
SLTNode* tail = *pphead;
while (tail->next->next != NULL)
{
tail = tail->next;
}
free(tail->next);
tail->next = NULL;
完整代码:
void SListPopBack(SLTNode** pphead)
{
assert(pphead);
// 温柔的检查
/*if (*pphead == NULL)
return;
*/
// 暴力检查
assert(*pphead != NULL);
if ((*pphead)->next == NULL) // 1、一个节点
{
free(*pphead);
*pphead = NULL;
}
else // 2、多个节点
{
SLTNode* tail = *pphead;
while (tail->next->next != NULL)
{
tail = tail->next;
}
free(tail->next);
tail->next = NULL;
}
}
思路:遍历链表找结点,并返回地址。
SLTNode* SListFind(SLTNode* phead, SLTDataType x)
{
SLTNode* cur = phead;
while (cur)
{
if (cur->data == x)
{
return cur;
}
cur = cur->next;
}
return NULL;
}
其中,我们也发现查找函数同样可以用来修改结点,我们可以在main函数直接设置。
//test.c
SLTNode* pos = SListFind(plist, 3);
if (pos)
{
// 修改
pos->data *= 10;
printf("找到了\n");
}
else
{
printf("没有找到\n");
}
SListPrint(plist);
思路:逐一遍历链表结点,然后逐个释放。
void SListDestory(SLTNode** pphead)
{
assert(pphead);
SLTNode* cur = *pphead;
//while (cur != NULL)
while (cur)
{
SLTNode* next = cur->next;
free(cur);
cur = next;
}
*pphead = NULL;
}
思路:找到pos
的位置,然后将待插入的结点链接到链表上。
我们可以在main函数里和find函数配合一下
// test.c
pos = SListFind(plist, 2);
if (pos)
{
SListInsert(&plist, pos, 20);
}
SListPrint(plist);
// 在pos之前插入
void SListInsert(SLTNode** pphead, SLTNode* pos, SLTDataType x)
{
assert(pphead);
assert(pos);
if (pos == *pphead) //头插
{
SListPushFront(pphead, x);
}
else
{
SLTNode* prev = *pphead;
while (prev->next != pos)
{
prev = prev->next;
// 暴力检查,pos不在链表中.prev为空,还没有找到pos,说明pos传错了
assert(prev);
}
SLTNode* newnode = BuySLTNode(x);
prev->next = newnode;
newnode->next = pos;
}
}
思路:找到pos
的位置,然后将待插入的结点链接到链表上。
void SListInsertAfter(SLTNode* pos, SLTDataType x)
{
assert(pos);
SLTNode* newnode = BuySLTNode(x);
newnode->next = pos->next;
pos->next = newnode;
}
思路:找到待删除数据的位置,将pos
上下两个结点链接起来,释放掉待删除数据。
// 删除pos位置
void SListErase(SLTNode** pphead, SLTNode* pos)
{
assert(pphead);
assert(pos);
if (*pphead == pos)
{
SListPopFront(pphead); //头删
}
else
{
SLTNode* prev = *pphead;
while (prev->next != pos)
{
prev = prev->next;
// 检查pos不是链表中的节点,参数传错了
assert(prev);
}
prev->next = pos->next;
free(pos);
//pos = NULL;
}
}
思路:找到待删除数据的位置,将pos->next
上下两个结点链接起来,释放掉待删除数据。注意不能对最后一个结点
后删。
// 删除pos后面位置
void SListEraseAfter(SLTNode* pos)
{
assert(pos);
if (pos->next == NULL)
{
return;
}
else
{
SLTNode* next = pos->next;
pos->next = next->next;
free(next);
}
}
优点:
O(1)
缺点:
// SList.h
#define _CRT_SECURE_NO_WARNINGS 1
#pragma once
#include
#include
typedef int SLTDataType;
typedef struct SListNode
{
SLTDataType data; //存储数据
struct SListNode* next; //指向下一个结点的地址
//SLTNode* next; 不可以这样
//SListNode* next;
}SLTNode;
//}SLTNode,*PSLTNode; (SLTNode是SListNode的重定义;*PSLTNode是struct SListNode的重定义)
void SListPrint(SLTNode* phead); //等价于void SListPrint( PSLTNode phead);
SLTNode* BuySLTNode(SLTDataType x);
void SListDestory(SLTNode** pphead);
void SListPushFront(SLTNode** pphead, SLTDataType x);
void SListPushBack(SLTNode** pphead, SLTDataType x);
void SListPopBack(SLTNode** pphead);
void SListPopFront(SLTNode** pphead);
SLTNode* SListFind(SLTNode* phead, SLTDataType x);
// 在pos之前插入
void SListInsert(SLTNode** pphead, SLTNode* pos, SLTDataType x);
// 在pos后面插入
void SListInsertAfter(SLTNode* pos, SLTDataType x);
// 删除pos位置
void SListErase(SLTNode** pphead, SLTNode* pos);
// 删除pos后面位置
void SListEraseAfter(SLTNode* pos);
// SList.c
#include"SList.h"
void SListPrint(SLTNode* phead) //遍历打印
{
//不用断言哦,因为链表为空是正常情况
SLTNode* cur = phead; //cur是指向这个链表的指针
while (cur != NULL)
{
printf("%d->", cur->data); //打印数据
cur = cur->next; //然后指向下一个结点,然后循环判断并继续打印
}
printf("NULL\n");
}
SLTNode* BuySLTNode(SLTDataType x)
{
SLTNode* newnode = (SLTNode*)malloc(sizeof(SLTNode)); // 动态申请一个空间
if (newnode == NULL)
{
perror("malloc fail");
exit(-1);
}
newnode->data = x; // 将新数据放到结构体的数据域中
newnode->next = NULL;// 链接下一个结点
return newnode;
}
void SListDestory(SLTNode** pphead)
{
assert(pphead);
SLTNode* cur = *pphead;
//while (cur != NULL)
while (cur)
{
SLTNode* next = cur->next;
free(cur);
cur = next;
}
*pphead = NULL;
}
void SListPushFront(SLTNode** pphead, SLTDataType x)
{
assert(pphead);
SLTNode* newnode = BuySLTNode(x); //把新结点申请出来
newnode->next = *pphead; //让新结点的next指向第一个老结点的pphead
*pphead = newnode; //把新申请的结点的地址再重新放到pphead上
}
void SListPushBack(SLTNode** pphead, SLTDataType x)
{
assert(pphead);
SLTNode* newnode = BuySLTNode(x);
// 1、空
// 2、非空
if (*pphead == NULL)
{
*pphead = newnode;
}
else
{
// 找尾
SLTNode* tail = *pphead;
while (tail->next != NULL)
{
tail = tail->next;
}
tail->next = newnode;
}
}
void SListPopBack(SLTNode** pphead)
{
assert(pphead);
// 温柔的检查
if (*pphead == NULL)
{
return;
}
// 暴力检查
//assert(*pphead != NULL);
// 1、一个节点
// 2、多个节点
if ((*pphead)->next == NULL)
{
free(*pphead);
*pphead = NULL;
}
else
{
// 找尾
/*SLTNode* prev = NULL;
SLTNode* tail = *pphead;
while (tail->next != NULL)
{
prev = tail;
tail = tail->next;
}
prev->next = NULL;
free(tail);
tail = NULL;*/
SLTNode* tail = *pphead;
while (tail->next->next != NULL)
{
tail = tail->next;
}
free(tail->next);
tail->next = NULL;
}
}
void SListPopFront(SLTNode** pphead)
{
assert(pphead);
// 温柔的检查
if (*pphead == NULL)
{
return;
}
// 暴力的检查
//assert(*pphead != NULL);
SLTNode* del = *pphead;
*pphead = (*pphead)->next;
free(del);
del = NULL;
}
SLTNode* SListFind(SLTNode* phead, SLTDataType x)
{
SLTNode* cur = phead;
while (cur)
{
if (cur->data == x)
{
return cur;
}
cur = cur->next;
}
return NULL;
}
// 在pos之前插入
void SListInsert(SLTNode** pphead, SLTNode* pos, SLTDataType x)
{
assert(pphead);
assert(pos);
if (pos == *pphead)
{
SListPushFront(pphead, x);
}
else
{
SLTNode* prev = *pphead;
while (prev->next != pos)
{
prev = prev->next;
// 暴力检查,pos不在链表中.prev为空,还没有找到pos,说明pos传错了
assert(prev);
}
SLTNode* newnode = BuySLTNode(x);
prev->next = newnode;
newnode->next = pos;
}
}
// 在pos后面插入
void SListInsertAfter(SLTNode* pos, SLTDataType x)
{
assert(pos);
SLTNode* newnode = BuySLTNode(x);
newnode->next = pos->next;
pos->next = newnode;
}
// 删除pos位置
void SListErase(SLTNode** pphead, SLTNode* pos)
{
assert(pphead);
assert(pos);
if (*pphead == pos)
{
SListPopFront(pphead);
}
else
{
SLTNode* prev = *pphead;
while (prev->next != pos)
{
prev = prev->next;
// 检查pos不是链表中的节点,参数传错了
assert(prev);
}
prev->next = pos->next;
free(pos);
//pos = NULL;
}
}
// 删除pos后面位置
void SListEraseAfter(SLTNode* pos)
{
assert(pos);
if (pos->next == NULL)
{
return;
}
else
{
SLTNode* next = pos->next;
pos->next = next->next;
free(next);
}
}
// test.c
#include"SList.h"
void TestSList1()
{
SLTNode* plist = NULL;
SListPushFront(&plist, 1);
SListPushFront(&plist, 2);
SListPushFront(&plist, 3);
SListPushFront(&plist, 4);
SListPrint(plist);
/*
SListPopFront(&plist);
SListPrint(plist);
SListPopFront(&plist);
SListPrint(plist);
SListPopFront(&plist);
SListPrint(plist);
SListPopFront(&plist);
SListPrint(plist);
SListPopFront(&plist);
SListPrint(plist);
SListDestory(&plist);
*/
}
void TestSList2()
{
SLTNode* plist = NULL;
SListPushBack(&plist, 1);
SListPushBack(&plist, 2);
SListPushBack(&plist, 3);
SListPushBack(&plist, 4);
SListPrint(plist);
SListPopBack(&plist);
SListPrint(plist);
/*
SListPopBack(&plist);
SListPrint(plist);
SListPopBack(&plist);
SListPrint(plist);
SListPopBack(&plist);
SListPrint(plist);
SListPopBack(&plist);
SListPrint(plist);
SListDestory(&plist);
*/
}
void TestSList3()
{
SLTNode* plist = NULL;
SListPushBack(&plist, 1);
SListPushBack(&plist, 2);
SListPushBack(&plist, 3);
SListPushBack(&plist, 4);
SListPrint(plist);
SLTNode* pos = SListFind(plist, 3);
if (pos)
{
// 修改
pos->data *= 10;
printf("找到了\n");
}
else
{
printf("没有找到\n");
}
SListPrint(plist);
pos = SListFind(plist, 2);
if (pos)
{
SListInsert(&plist, pos, 20);
}
SListPrint(plist);
pos = SListFind(plist, 1);
if (pos)
{
SListInsert(&plist, pos, 10);
}
SListPrint(plist);
SListDestory(&plist);
}
void TestSList4()
{
SLTNode* plist = NULL;
SListPushBack(&plist, 1);
SListPushBack(&plist, 2);
SListPushBack(&plist, 3);
SListPushBack(&plist, 4);
SListPrint(plist);
SLTNode* pos = SListFind(plist, 3);
if (pos)
{
SListErase(&plist, pos);
pos = NULL;
}
SListPrint(plist);
pos = SListFind(plist, 1);
if (pos)
{
SListErase(&plist, pos);
pos = NULL;
}
SListPrint(plist);
}
int main()
{
TestSList3();
//TestSList4();
return 0;
}
//void swapi(int* px, int* py)
//{
// int tmp = *px;
// *px = *py;
// *py = tmp;
//}
//
//void swapptr(int** ppx, int** ppy)
//{
// int* tmp = *ppx;
// *ppx = *ppy;
// *ppy = tmp;
//}
//
//int main()
//{
// int x = 0, y = 1;
// swapi(&x, &y);
//
// int* p1 = &x, *p2 = &y;
// swapi(p1, p2);
//
// swapptr(&p1, &p2);
//
// return 0;
//}
OK,以上就是本期知识点“单链表”的知识啦~~ ,感谢友友们的阅读。后续还会继续更新,欢迎持续关注哟~
如果觉得收获满满,可以点点赞支持一下哟~