链表
链表的概念
- 链表是一种物理存储结构上非连续、非顺序的存储结构,数据元素的逻辑顺序是通过链表中的指针链接次序实现的
- 链表中的元素可以处在任意位置,各个元素之间通过指针链接
- 由于链表并不连续,所以不用担心容量问题,只需创建一个新的节点,通过指针链接即可
- 这次实现的是单链表,结构简单,一般不会单独用来存数据
单链表接口的实现
🧨使用的平台是VS2019
🧨pro.c(主函数以及测试程序)
🧨SList.c(单链表各个功能函数的实现)
🧨SList.h(单链表函数的声明,头文件的引用)
函数的声明
SList.h
#pragma once
#include <stdio.h>
#include <assert.h>
#include <stdlib.h>
typedef int SLTDataType;
typedef struct SListNode
{
SLTDataType data;
struct SListNode* next;
}SLTNode;
SLTNode* BuySLTNode(SLTDataType x);//创建节点
void SListPrint(SLTNode* phead);//单链表打印
void SListDestroy(SLTNode** phead);//单链表销毁
void SListPushFront(SLTNode** pphead, SLTDataType x);//头部插入
void SListPushBack(SLTNode** pphead, SLTDataType x);//尾部插入
void SListPopFront(SLTNode** phead);//头部删除
void SListPopBack(SLTNode** phead);//尾部删除
SLTNode* SListFind(SLTNode* phead, SLTDataType x);//查找
//在pos之前插入
void SListInsert(SLTNode** pphead, SLTNode* pos, SLTDataType x);
void SListInsertAfter(SLTNode* pos, SLTDataType x);//在pos之后插
//删除pos位置
//void SListErase(SLTNode** pphead, SLTNode* pos);
SList.c
打印单链表
void SListPrint(SLTNode* phead)
{
SLTNode* cur = phead;
while (cur != NULL)//cur是个结构体指针
{
printf("%d->", cur->data);
cur = cur->next;//cur->next下一个节点的地址
}
printf("NULL\n");
}
1.在主函数中定义 SLTNode* plist = NULL; ,结构体类型的变量plist
2.由于在后续函数中可能需要遍历链表,所以链表头不能动,把值赋给临时变量cur,利用cur打印结构体成员数据
3.由于cur->next中存的是下一个节点的地址,所以cur=cur->next,寻找下一个节点的地址
动态申请一个新的节点
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;
}
1.x就是所要插入新的节点的数据
2.利用malloc开辟一个 SLTNode* 的空间,空间里有个数据域和指针域,并判断是否为空
3.将x赋给新节点的data,新节点的next置为空,并且返回新节点的地址
头部插入一个节点
void SListPushFront(SLTNode** pphead, SLTDataType x)//头部插入
{
assert(pphead);
SLTNode* newnode = BuySLTNode(x);
newnode->next = *pphead;
*pphead = newnode;
}
1.将主函数中plist的地址传进来,对*(pphead)就是plist,通过操作*(pphead)实现对plist的改变,传地址的原因是因为要改plist的指向,如果只传进来 SLTNode类型的变量,无法起到修改作用,只有传地址,再解引用才能真正的改变主函数中的值,传任何形式的变量都无法修改
2.传二级指针的原因是要改变plist指向的位置,因为其类型是 SLTNode,如果函数参数也是此类型,改变的只是形参,形参只是实参的一份临时拷贝,形参的改变不会影响到实参,所以在主函数传的是&plist,由于plist的类型是 SLTNode*,所以函数的参数的类型是 SLTNode**
3.由于pplead存的是plist的地址,肯定不为空,所以进行assert
4.每次插入之前创建一个新的节点
尾部插入一个节点
void SListPushBack(SLTNode** pphead, SLTDataType x)//尾部插入
{
assert(pphead);//pphead存的是plist的地址,不会是空
SLTNode* newnode = BuySLTNode(x);
if (*pphead == NULL)
{
*pphead = newnode;
}
else
{
SLTNode* tail = *pphead;
while (tail->next != NULL)
{
tail = tail->next;
}
tail->next = newnode;
}
}
1.尾部插入也是先创建一个新的节点,但是分两种情况
2.第一种是本来没有节点,直接尾插,将newnode的地址赋给*pphead
3.第二种是利用tail遍历所有节点的next,直到找到NULL,再将新节点的地址赋给tail->next
头部删除节点
void SListPopFront(SLTNode** pphead)//头部删除
{
assert(pphead);
if (*pphead == NULL)
{
return;
}
SLTNode* del = *pphead;
*pphead = (*pphead)->next;
free(del);
del = NULL;
}
1.先判断是否有节点,没有则不进行删除操作
2.如果有节点,先将要删除节点的地址保存下来,将下一个节点的地址赋值给*(pphead)
3.最后将要删除的节点的地址释放
尾部删除节点
void SListPopBack(SLTNode** pphead)//尾部删除
{
assert(pphead);
assert(*pphead != NULL);//没有
if ((*pphead)->next == NULL)//只有一个
{
free(*pphead);
*pphead = NULL;
}
SLTNode* prev = NULL;//多个
SLTNode* tail = *pphead;
while (tail->next != NULL)
{
prev = tail;
tail = tail->next;
}
prev->next = NULL;
free(tail);
tail = NULL;
}
1.没有节点时,直接断言assert
2.只有一个节点时,直接将其释放
3.多个节点时:关键是需要找到前一个节点,使用prev找要删除的前一个几点,利用tail遍历所有的节点,直到找到NULL,然后将prev->next置为空,释放掉要删除的节点
销毁所有节点
void SListDestroy(SLTNode** pphead)
{
assert(pphead);
SLTNode* cur = *pphead;
while (cur != NULL)
{
SLTNode* next = cur->next;
free(cur);
cur = next;
}
*pphead = NULL;
}
1.利用cur遍历所有节点,如果不为空,保存下一个节点地址后,释放当前节点,最后将第一个节点释放
查找节点
SLTNode* SListFind(SLTNode* phead, SLTDataType x)//查找
{
SLTNode* cur = phead;
while (cur)
{
if (cur->data == x)
{
return cur;
}
cur = cur->next;
}
return NULL;
//while (cur->data != x)
//{
// cur = cur->next;
//}
//return
}
1.利用cur遍历所有节点,直到找到与该节点存储的数据,返回该节点的地址,如果没有找到,返回空指针
在pos之前插入数据
void SListInsert(SLTNode** pphead, SLTNode* pos, SLTDataType x)//在pos之前插入
{
assert(pphead);
assert(pos);
if (pos == *pphead)
{
SListPushFront(pphead, x);
}
else
{
SLTNode* prev = *pphead;
while (prev->next != pos)
{
prev = prev->next;
assert(prev);
}
SLTNode* newnode = BuySLTNode(x);
prev->next = newnode;
newnode->next = pos;
}
}
1.如果在第一个节点插入,就是头插,调用相关函数即可
2.其他情况,主要目标是找到前一个节点,利用prev->next,找到下一个节点,assert是为了防止prev为空,找到最后都没有,说明传的pos有误
3.创建一个新的节点,再赋值
在pos之后插入数据
void SListInsertAfter(SLTNode* pos, SLTDataType x)//在pos之后插
{
assert(pos);
SLTNode* newnode = BuySLTNode(x);
newnode->next = pos->next;
pos->next = newnode;
}
1.在pos之后插,先创建一个新的节点,将pos下一个节点的地址给newnode->next,将newnode的地址赋给pos->next
删除pos位置的值
void SListErase(SLTNode** pphead, SLTNode* pos)//删除pos位置的值
{
assert(pphead);
assert(*pphead);
if (*pphead == pos)
{
SListPopFront(pphead);
}
else
{
SLTNode* cur = *pphead;
while (cur->next != pos)
{
cur = cur->next;
assert(cur);//检查pos是否为链表中的节点
}
cur->next = pos->next;
free(pos);
}
}
1.如果plist为空,没有节点,不能删除
2.如果只有一个节点,就是头删,调用函数
3.如果有多个节点,关键还是找到前一个节点,将前一个节点的cur->next置NULL,释放掉pos
删除pos位置之后的值
void SListEraseAfter(SLTNode* pos)//删除pos之后的值
{
assert(pos);
if (pos->next == NULL)
{
return;
}
else
{
SLTNode* next = pos->next;
pos->next = next->next;
free(next);
}
}
1.如果pos->next是NULL说明是最后一个节点,或仅此一个节点,不能删除
2.若不是NULL,主要是找到pos后第二个位置的节点,即pos->next->next,将该地址赋给pos->next,最后释放掉next
链表优点和缺点
优点:非常适合头插头删,时间复杂度为O(1)
缺点:如果我们想要删除或插入头以外的位置时,必须要找到该点的前一个节点,时间复杂度为O(N)
双向链表
1.无论是next还是prev,其指向的都是某个节点的地址(该节点的地址)
2.带哨兵头的双向循环链表,结构最复杂,一般用在单独存储数据。实际中使用的链表数据结构,都是带头双向循环链表
双向链表接口的实现
函数的声明
#pragma once
#include <stdio.h>
#include <assert.h>
#include <stdlib.h>
#include <stdbool.h>
typedef int LTDataType;
typedef struct ListNode
{
struct ListNode* next;
struct ListNode* prev;
LTDataType data;
}LTNode;
//void ListInit(LTNode** pphead);
void ListPrint(LTNode* phead);
void ListDestroy(LTNode* phead);
LTNode* ListInit();
void ListPushBack(LTNode* phead, LTDataType x);
void ListPushFront(LTNode* phead, LTDataType x);
void ListPopBack(LTNode* phead);
void ListPopFront(LTNode* phead);
bool ListEmpty(LTNode* phead);
size_t ListSize(LTNode* phead);
LTNode* ListFind(LTNode* phead, LTDataType x);
//在pos之前插入
void ListInsert(LTNode* pos, LTDataType x);
//删除pos位置
void ListErase(LTNode* pos);
初始化链表
LTNode* ListInit()//初始化
{
LTNode* guard = (LTNode*)malloc(sizeof(LTNode));//哨兵位头
if (guard == NULL)
{
perror("guard");
exit(-1);
}
guard->next = guard;
guard->prev = guard;
return guard;
}//phead、plist都是指向哨兵位的头节点
打印链表
void ListPrint(LTNode* phead)
{
assert(phead);
LTNode* cur = phead->next;
printf("guardHead<=>");
while (cur != phead)
{
printf("%d<=>", cur->data);
cur = cur->next;
}
printf("\n");
}
创建节点
LTNode* BuyListNode(LTDataType x)
{
LTNode* node = (LTNode*)malloc(sizeof(LTNode));//哨兵位头
if (node == NULL)
{
perror("node");
exit(-1);
}
node->next = NULL;
node->prev = NULL;
node->data = x;
return node;
}
尾插
void ListPushBack(LTNode* phead, LTDataType x)//尾插
{
assert(phead);
//LTNode* newnode = BuyListNode(x);
//LTNode* tail = phead->prev;
//tail->next = newnode;
//newnode->prev = tail;
//newnode->next = phead;
//phead->prev = newnode;
ListInsert(phead, x);
}
头插
void ListPushFront(LTNode* phead, LTDataType x)//头插
{
assert(phead);
//LTNode* newnode = BuyListNode(x);
//newnode->next = phead->next;
//phead->next->prev = newnode;
//phead->next = newnode;
//newnode->prev = phead;
ListInsert(phead->next, x);
}
尾删
void ListPopBack(LTNode* phead)//尾删
{
assert(phead);
assert(!ListEmpty(phead));
//LTNode* tail = phead->prev;
//LTNode* prev = tail->prev;
//prev->next = phead;
//phead->prev = prev;
//free(tail);
ListErase(phead->prev);
}
头删
void ListPopFront(LTNode* phead)//头删
{
assert(phead);
//LTNode* first = phead->next;
//LTNode* second = first->next;
//phead->next = second;
//second->prev = phead;
//free(first);
ListErase(phead->next);
}
查找
LTNode* ListFind(LTNode* phead, LTDataType x)//查找
{
assert(phead);
LTNode* cur = phead->next;
while (cur != phead)
{
if (cur->data == x)
{
return cur;
}
cur = cur->next;
}
return NULL;
}
在pos之前插入
void ListInsert(LTNode* pos, LTDataType x)//在pos之前插入x
{
assert(pos);
LTNode* newnode = BuyListNode(x);
LTNode* prev = pos->prev;
prev->next = newnode;
newnode->prev = prev;
newnode->next = pos;
pos->prev = newnode;
}
删除节点
void ListErase(LTNode* pos)
{
assert(pos);
LTNode* prev = pos->prev;
LTNode* next = pos->next;
prev->next = next;
next->prev = prev;
free(pos);
}
销毁节点
void ListDestroy(LTNode* phead)
{
assert(phead);
LTNode* cur = phead->next;
while (cur != phead)
{
LTNode* next = cur->next;
free(cur);
cur = next;
}
free(phead);
}
判断是否为空
bool ListEmpty(LTNode* phead)
{
assert(phead);
return phead->next == phead;
}
判断节点数量
size_t ListSize(LTNode* phead)
{
assert(phead);
size_t n = 0;
LTNode* cur = phead->next;
while (cur != phead)
{
n++;
cur = cur->next;
}
return n;
}