1.代码位置
2.概念与结构
概念：链表是⼀种物理存储结构上⾮连续、⾮顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。
一些知识点：除了哨兵位节点，其它节点都存储有效数据
2.1结点
与顺序表不同的是，链表⾥的每节"⻋厢"都是独⽴申请下来的空间，我们称之为“结点/结点”
结点的组成主要有两个部分：当前结点要保存的数据和保存下⼀个结点的地址（指针变量）。
图中指针变量 plist保存的是第⼀个结点的地址，我们称plist此时“指向”第⼀个结点，如果我们希望plist“指向”第⼆个结点时，只需要修改plist保存的内容为0x0012FFA0。
链表中每个结点都是独⽴申请的（即需要插⼊数据时才去申请⼀块结点的空间），我们需要通过指针变量来保存下⼀个结点位置才能从当前结点找到下⼀个结点。
3.链表的性质
1、链式机构在逻辑上是连续的，在物理结构上不⼀定连续
2、结点⼀般是从堆上申请的
3、从堆上申请来的空间，是按照⼀定策略分配出来的，每次申请的空间可能连续，可能不连续
4.链表的分类
几个注意的点：d1是不带头 head是带头 除了头结点，其它结点都存储有效数据
虽然有这么多的链表的结构，但是我们实际中最常⽤还是两种结构：单链表和双向带头循环链表
- 无头单向非循环链表：结构简单，⼀般不会单独⽤来存数据。实际中更多是作为其他数据结构的子结构，如哈希桶、图的邻接表等等。另外这种结构在笔试⾯试中出现很多。
- 带头双向循环链表：结构最复杂，⼀般⽤在单独存储数据。实际中使⽤的链表数据结构，都是带头双向循环链表。另外这个结构虽然结构复杂，但是使⽤代码实现以后会发现结构会带来很多优势，实现反而简单了，后⾯我们代码实现了就知道了。
5.单链表的实现
第一个结点：*plist ————> **pphead
指向第一个节点的指针：plist————> *pphead
指向第一个节点的指针的地址：&plist————> pphead
pphead是链表头指针的指针，允许销毁链表的函数不仅访问链表，还要能够修改链表头指针本身
*pphead 是链表的第一个结点的指针
pphead 保证函数能够正确操作链表头指针
*pphead 确保链表确实包含结点
5.1单链表的创建打印及销毁
.h文件
#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
//传二级指针是为了改变函数外边的一级指针变量
//定义链表（结点）的结构
typedef int SLTDatatype;
typedef struct SListNode {
SLTDatatype data;
struct SListNode* next;
}SLTNode;
//创建一个结构体链表SLTNode,一个存数据data，一个链表指针next
void SLTPrint(SLTNode* phead);
//创建一个结构体链表SLTNode,一个存数据data，一个链表指针next
void SLTPrint(SLTNode* phead);
//销毁链表
void SListDestroy(SLTNode** pphead);
.c文件
```c
//链表的打印，遍历链表 链表只能往后遍历 不能往前找
void SLTPrint(SLTNode* phead)
{
SLTNode* pcur = phead;
while (pcur)
{
printf("%d->", pcur->data);
pcur = pcur->next;
}
printf("NULL\n");
}
//申请新节点
//SLTBuyNode是函数 返回类型是结构体指针 （传参）
SLTNode* SLTBuyNode(SLTDatatype x)
{
SLTNode* node = (SLTNode*)malloc(sizeof(SLTNode));
//创建一个结点node 申请多大的内存
if (node == NULL)
{
perror("malloc fail!");
exit(1);
}
node->data = x;
node->next = NULL;
return node;
}
//销毁链表
void SListDestroy(SLTNode** pphead)
{
assert(pphead && *pphead);
SLTNode* pcur = *pphead;
while (pcur)
{
SLTNode* next = pcur->next;
free(pcur);
pcur = next;
}
*pphead=NULL;
}
## 5.2单链表的插入
```c
//插入
void SLTPushBack(SLTNode** pphead, SLTDatatype x)
{
实参plist，形参phead，形参的改变不能影响实参，若要改变，必须传实参地址（传变量得地址）
assert(pphead);
//pphead是&plist(&phead) *pphead是phead(链表头指针）
//pphead是链表头指针的指针
//申请新节点
SLTNode* newnode = SLTBuyNode(x);
if (*pphead == NULL)
{
*pphead = newnode;
}
else
{
//找尾结点 因为是函数内 所以用二级指针改变phead的指针
//同级不改变 改变大一级 题目很明确有一级 你就用二级接收
SLTNode* pcur = *pphead;
while (pcur->next)
{
pcur = pcur->next;
}
pcur->next=newnode;
}
}
//只要形参的改变影响实参，就用二级指针
void SLTPushFront(SLTNode** pphead, SLTDatatype x)
{
assert(pphead);
SLTNode* newnode = SLTBuyNode(x);
newnode->next = *pphead;
*pphead = newnode;
}
//在指定位置之前插入数据
void SLTInsert(SLTNode** pphead, SLTNode* pos, SLTDatatype x)
{
//可能会在pphead之前插入，所以**
assert(pphead);
assert(pos);
//最前面插入数据
if (pos == *pphead)
{
SLTPushFront(pphead, x);//调用头插
}
else
{
SLTNode* newnode = SLTBuyNode(x);
//找prev（pos的前一个结点）
SLTNode* prev = *pphead;
while (prev->next != pos)
{
prev = prev->next;
}
newnode->next = pos;
prev->next = newnode;
}
}
//在指定位置之后插入数据
void SLTInsertAfter(SLTNode* pos, SLTDatatype x)
{
assert(pos);
SLTNode* newnode = SLTBuyNode(x);
newnode->next = pos->next;
pos->next = newnode;
}
5.2单链表的插入
见上
5.3单链表的删除
//删除
void SLTPopBack(SLTNode** pphead)
{
//链表为空不能删除
assert(pphead && *pphead);
//处理只有一个链表的情况，要删除的就是头结点
if ((*pphead)->next == NULL)
{
free(*pphead);
*pphead = NULL;
}
else
{
//找prev ptail 不能直接找到尾节点，要从头循环
SLTNode* ptail = *pphead;
SLTNode* prev = NULL;
while (ptail->next)
{
prev = ptail;
ptail = ptail->next;
}
prev->next = NULL;
free(ptail);
ptail = NULL;
}
}
void SLTPopFront(SLTNode** pphead)
{
assert(pphead && *pphead);
SLTNode* next = (*pphead)->next;
free(*pphead);
*pphead = next;
}
```c
//删除pos结点
void SLTErase(SLTNode** pphead, SLTNode* pos)
{
assert(pphead && *pphead);
assert(pos);
//头删
if (pos == *pphead)
{
SLTPopFront(pphead);
}
else
{
SLTNode* prev = *pphead;
while (prev->next != pos)
{
prev = prev->next;
}
prev->next = pos->next;
free(pos);
pos = NULL;
}
}
//删除pos之后的结点
void SLTEraseAfter(SLTNode* pos)
{
assert(pos && pos->next);
SLTNode* del = pos->next;
pos->next = pos->next->next;
free(del);
del = NULL;
}
## 5.4单链表查找指定位置的结点
```c
//查找 查找不修改 所以传一级
SLTNode* SLTFind(SLTNode* phead, SLTDatatype x)
{
assert(phead);
SLTNode* pcur = phead;
while (pcur)
{
if (pcur->data == x)
{
return pcur;//返回指针
}
pcur = pcur->next;
}
//没有找到
return NULL;
}
补充test.c测试文件
#define _CRT_SECURE_NO_WARNINGS 1
#include "SList.h"
//创建一个链表，并打印链表 一般不用这个方法
void createSList()
{
//链表是有一个一个的结点组成
SLTNode* Node1 = (SLTNode*)malloc(sizeof(SLTNode));
Node1->data = 1;
SLTNode* Node2 = (SLTNode*)malloc(sizeof(SLTNode));
Node2->data = 2;
SLTNode* Node3 = (SLTNode*)malloc(sizeof(SLTNode));
Node3->data = 3;
SLTNode* Node4 = (SLTNode*)malloc(sizeof(SLTNode));
Node4->data = 4;
Node1->next = Node2;
Node2->next = Node3;
Node3->next = Node4;
Node4->next = NULL;
//第一个结点的地址作为参数传过去
SLTNode* plist = Node1;
SLTPrint(plist);
}
void SListTest01()
{
SLTNode* plist = NULL;
SLTPushBack(&plist, 1);
SLTPushBack(&plist, 2);
SLTPushBack(&plist, 3);
SLTPushBack(&plist, 4);
SLTPrint(plist);
//1->2->3->4->NULL
//SLTPushFront(&plist, 1);
//SLTPushFront(&plist, 2);
//SLTPushFront(&plist, 3);
//SLTPushFront(&plist, 4);
//SLTPrint(plist); //4321NULL
//SLTPopBack(&plist);
//SLTPrint(plist);
//SLTPopBack(&plist);
//SLTPrint(plist);
//SLTPopBack(&plist);
//SLTPrint(plist);
/*SLTPopFront(&plist);
SLTPrint(plist);*/
/*SLTPopFront(&plist);
SLTPrint(plist);
SLTPopFront(&plist);
SLTPrint(plist);*/
SLTNode* find = SLTFind(plist, 4);
if (find == NULL)
{
printf("未找到\n");
}
else
{
printf("找到了\n");
}
SLTInsert(&plist, find, 11);//考虑头插 所以可能改变头 123 11 4
//SLTInsertAfter(find, 12); // 1234 12
//SLTPrint(plist);
//SLTErase(&plist, find);//123
//SLTEraseAfter(find);//1234
//SLTPrint(plist);
//SListDestroy(&plist);
//SLTPrint(plist);
}
int main()
{
//createSList();
SListTest01();
return 0;
}
扫一扫
525
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
