前言
紧接上期内容，你还记得我们上期最后留下的那个问题吗？如果不太记得了，没有关系，我们可以再回忆一下：
顺序表问题与思考
• 中间/头部的插⼊删除，时间复杂度为O(N)
• 增容需要申请新空间，拷⻉数据，释放旧空间。会有不⼩的消耗。
• 增容⼀般是呈2倍的增⻓，势必会有⼀定的空间浪费。例如当前容量为100，满了以后增容到200，我们再继续插⼊了5个数据，后⾯没有数据插⼊了，那么就浪费了95个数据空间。
思考：如何解决以上问题呢？
如果你已经忘记了顺序表的内容，那不好意思了，你还需要返回上期博客进行复习重温一下了！
如何解决空间浪费的问题呢？
这就是我们这期博客要讲述的内容了，那么还是话不多说，直接上干货：单链表！！！
单链表的认识
1.概念与结构
概念：链表是⼀种物理存储结构上⾮连续、⾮顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。你可以把它想象成为一辆火车，一节一节连接着的火车，这样下来，我们对于单链表的理解就非常容易了！
淡季时⻋次的⻋厢会相应减少，旺季时⻋次的⻋厢会额外增加⼏节。只需要将⽕⻋⾥的某节⻋厢去掉/加上，不会影响其他⻋厢，每节⻋厢都是独⽴存在的。那么在链表⾥，每节“⻋厢”是什么样的呢？请看下图：
由上图我们可以看到，每一个车厢内都有一个数据变量和一个指针变量，当然车头可以有数据变量，也可以没有数据变量，这个就涉及后边的哨兵位知识点了，那么你现在只需要记得单链表的结构即可，后边的知识咱们后边再聊！
2.结点
与顺序表不同的是，链表⾥的每节"⻋厢"都是独⽴申请下来的空间，我们称之为“ 结点/结点 ”结点的组成主要有两个部分： 当前结点要保存的数据 和 保存下⼀个结点的地址 （ 指针变量 ）。图中 指针变量 plist保存的是第⼀个结点的地址 ，我们称plist此时“指向”第⼀个结点，如果我们希望plist“指向”第⼆个结点时，只需要修改plist保存的内容为0x0012FFA0。链表中每个结点都是独⽴申请的（即需要插⼊数据时才去申请⼀块结点的空间），我们需要通过指针变量来保存下⼀个结点位置才能从当前结点找到下⼀个结点。
3.单链表的结构特点：
单链表是线性表的一种
逻辑结构：线性的；
物理结构：不一定是线性的，也有可能是线性的；
4.链表的性质
1、链式结构在逻辑上是连续的，在物理结构上不⼀定连续2、结点⼀般是从堆上申请的3、从堆上申请来的空间，是按照⼀定策略分配出来的每次申请的空间可能连续，可能不连续
结合前⾯学到的结构体知识，我们可以给出每个结点对应的结构体代码：
假设当前保存的结点为整型：
struct SListNode
{
int data; //结点数据
struct SListNode* next; //指针变量⽤保存下⼀个结点的地址
}
当我们想要保存⼀个整型数据时，实际是向操作系统申请了⼀块内存，这个内存不仅要保存整型数
据，也需要保存下⼀个结点的地址（当下⼀个结点为空时保存的地址为空）。
当我们想要从第⼀个结点⾛到最后⼀个结点时，只需要在当前结点拿上下⼀个结点的地址就可以了。
5.链表的打印
给定的链表结构中，如何实现结点从头到尾的打印？
思考：当我们想保存的数据类型为字符型、浮点型或者其他⾃定义的类型时，该如何修改？
提示：回去看一眼顺序表的类型定义那里的typedef struct，联想一下你就会知道了。
单链表的实现
单链表的增删改查
1.SList.h文件的代码：
#pragma once
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
typedef int SLTDateType;
//定义单链表的结构
typedef struct SListNode
{
SLTDateType data;
struct SListNode* next;
}SLTNode;
//打印单链表
void SLTPrint(SLTNode* phead);
//头插法插入数据
void SLTPushFront(SLTNode** pphead, SLTDateType x);
//尾插法插入数据
void SLTPushBack(SLTNode** pphead, SLTDateType x);
//头删法删除结点
void SLTPopFront(SLTNode** pphead);
//尾删法删除结点
void SLTPopBack(SLTNode** pphead);
//查找指定数据的单链表
SLTNode* SLTFind(SLTNode* phead, SLTDateType x);
//在指定位置之前插入数据
void SLTInsertFront(SLTNode** pphead, SLTNode* pos, SLTDateType x);
//在指定位置之后插入数据
void SLTInsertAfter(SLTNode* pos, SLTDateType x);
//删除pos结点
void SLTErase(SLTNode** pphead, SLTNode* pos);
//删除pos结点之后的结点
void SLTErase(SLTNode* pos);
//单链表的销毁
void SLTDestroy(SLTNode** pphead);2.SList.c文件的代码：
#define _CRT_SECURE_NO_WARNINGS
#include "SList.h"
//打印单链表
void SLTPrint(SLTNode* phead)
{
SLTNode* pcur = phead;
while (pcur)
{
printf("%d->", pcur->data);//打印单链表中的数据
pcur = pcur->next;//指向下一个结点
}
printf("NULL\n");//当单链表遍历结束之后就打印NULL
}
//在插入数据之前先申请一个结点空间
SLTNode* SLTBuyNode(SLTDateType x)
{
SLTNode* node = (SLTNode*)malloc(sizeof(SLTNode));
if (node == NULL)
{
printf("malloc fail!");
exit(1);
}
node->data = x;
node->next = NULL;
return node;
}
//头插法插入数据
void SLTPushFront(SLTNode** pphead, SLTDateType x)
{
assert(pphead);//先判断结点不能为空
//注意下边两个概念的辨析：
//pphead --> &plist
// *pphead --> plist
//申请新节点
SLTNode* newnode = SLTBuyNode(x);
//将新结点的下一个指针指向头结点
newnode->next = *pphead;
//将新添加的这个结点作为头结点
*pphead = newnode;
}
//尾插法插入数据
void SLTPushBack(SLTNode** pphead, SLTDateType x)
{
assert(pphead);
//申请新的结点
SLTNode* newnode = SLTBuyNode(x);
if (*pphead == NULL)//如果头结点为空
{
*pphead = newnode;//那么就将新添加的这个结点作为头结点
}
else
{
//寻找尾结点
SLTNode* pcur = *pphead;//重新定义一个指针
while (pcur->next)//当这个结点遍历到结尾的时候
{
pcur = pcur->next;
}
pcur->next = newnode;//将新的结点作为尾部的下一个结点
}
}
//头删法删除结点
void SLTPopFront(SLTNode** pphead)
{
//链表为空，不可以删除
assert(pphead && *pphead);
SLTNode* next = (*pphead)->next;
free(*pphead);
*pphead = next;
}
//尾删法删除结点
void SLTPopBack(SLTNode** pphead)
{
//链表为空，不可以删除
assert(pphead && *pphead);
//先处理只有一个结点的情况，要删除的就是头结点
if ((*pphead)->next==NULL)
{
free(pphead);
*pphead = NULL;
}
else
{
SLTNode* ptail = *pphead;
SLTNode* pcur = NULL;
while (ptail->next)
{
pcur = ptail;
ptail = ptail->next;
}
ptail->next = NULL;
free(ptail);
ptail = NULL;
}
}
//查找含有指定数据的结点
SLTNode* SLTFind(SLTNode* phead, SLTDateType x)
{
assert(phead);
SLTNode* pcur = phead;
while (pcur)
{
if (pcur->data == x)
{
return pcur;
}
pcur = pcur->next;
}
//如果没有找到
return NULL;
}
//在指定位置之前插入数据
void SLTInsertFront(SLTNode** pphead, SLTNode* pos, SLTDateType x)
{
assert(pphead);
assert(pos);
//如果指定位置就是头结点的话,在之前插入数据就是头插即可
if (pos == *pphead)
{
SLTPushFront(pphead, x);
}
else
{
//先创造一个新的结点
SLTNode* newnode = SLTBuyNode(x);
//先找pos 的之前的一个结点
SLTNode* pcur = *pphead;
while (pcur->next != pos)
{
pcur = pcur->next;
}
newnode->next = pos;
pcur->next = newnode;
}
}
//在指定位置之后插入数据
void SLTInsertAfter(SLTNode* pos, SLTDateType x)
{
assert(pos);
//仍然是先新创造一个结点
SLTNode* newnode = SLTBuyNode(x);
newnode->next = pos->next;
pos->next = newnode;
}
//删除pos结点
void SLTErase(SLTNode** pphead, SLTNode* pos)
{
assert(pphead && *pphead);
assert(pos);
//当pos结点就是头结点，则使用头删法即可
if (pos == *pphead)
{
SLTPopFront(pphead);
}
SLTNode* pcur = *pphead;
while (pcur->next != pos)
{
pcur = pcur->next;
}
pcur->next = pos->next;
free(pos);
pos = NULL;
}
//删除pos结点之后的结点
void SLTErase(SLTNode* pos)
{
//pos的位置不能是尾结点，否则会报错
assert(pos && pos->next);
//创建一个指针表示pos之后的结点
SLTNode* del = pos->next;
pos->next = pos->next->next;
free(del);
del = NULL;
}
//单链表的销毁
void SLTDestroy(SLTNode** pphead)
{
assert(pphead && *pphead);
SLTNode* pcur = *pphead;
while (pcur)
{
SLTNode* next = pcur->next;
free(pcur);
pcur = next;
}
*pphead = NULL;
}3.text.c文件的代码：
#define _CRT_SECURE_NO_WARNINGS
#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
//SLTPushBack(NULL, 3);
//SLTPushFront(&plist, 1);
//SLTPushFront(&plist, 2);
//SLTPushFront(&plist, 3);
//SLTPushFront(&plist, 4);
//SLTPrint(plist); //4->3->2->1->NULL
//SLTPopBack(&plist);
//SLTPrint(plist);
//SLTPopBack(&plist);
//SLTPrint(plist);
//SLTPopBack(&plist);
//SLTPrint(plist);
//SLTPopBack(&plist);
//SLTPrint(plist);
//SLTPopBack(&plist);
//SLTPrint(plist);
//
//SLTPopFront(&plist);
//SLTPrint(plist);
//SLTPopFront(&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);//4->3->2->11->1->NULL
//SLTInsertAfter(find, 11);
//SLTPrint(plist);1->11->2->3->4->NULL
//SLTErase(&plist, find);// 1->2->3->NULL
//SLTEraseAfter(find);
//SLTPrint(plist);
SListDestroy(&plist);
SLTPrint(plist);
}
struct ListNode {
int val;
struct ListNode* next;
};
typedef struct ListNode ListNode;
struct ListNode* removeElements(struct ListNode* head, int val) {
//创建新链表
ListNode* newHead, * newTail;
newHead = newTail = NULL;
//遍历原链表
ListNode* pcur = head;
while (pcur)
{
//找值不为val的节点，往新链表中进行尾插
if (pcur->val != val)
{
//链表为空
if (newHead == NULL)
{
newHead = newTail = pcur;
}
else
{
//链表不为空
newTail->next = pcur;
newTail = newTail->next;
}
}
pcur = pcur->next;
}
return newHead;
}
void test01()
{
ListNode* n1 = (ListNode*)malloc(sizeof(ListNode));
n1->val = 1;
ListNode* n2 = (ListNode*)malloc(sizeof(ListNode));
n2->val = 6;
ListNode* n3 = (ListNode*)malloc(sizeof(ListNode));
n3->val = 1;
ListNode* n4 = (ListNode*)malloc(sizeof(ListNode));
n4->val = 6;
n1->next = n2;
n2->next = n3;
n3->next = n4;
n4->next = NULL;
//1->6->1->6
ListNode* plist = n1;
//构造一个链表
removeElements(plist, 6);
//1->1
}
int main()
{
//createSList();
//SListTest01();
test01();
return 0;
}测试代码需要大家自己去尝试一下，在这里博主就不展示测试代码的截图了。
链表的分类
链表的结构⾮常多样，以下情况组合起来就有8种（2 x 2 x 2）链表结构：
链表说明：
虽然有这么多的链表的结构，但是我们实际中最常⽤还是两种结构：单链表和双向带头循环链表1. ⽆头单向⾮循环链表：结构简单，⼀般不会单独⽤来存数据。实际中更多是作为其他数据结构的⼦ 结构，如哈希桶、图的邻接表等等。另外这种结构在笔试⾯试中出现很多。2. 带头双向循环链表：结构最复杂，⼀般⽤在单独存储数据。实际中使⽤的链表数据结构，都是带头 双向循环链表。另外这个结构虽然结构复杂，但是使⽤代码实现以后会发现结构会带来很多优势，实 现反⽽简单了，后⾯我们代码实现了就知道了。
单链表和顺序表的对比
总结
以上便是单链表的相关基础知识点，它解决了顺序表的相关问题。当然单链表也不是完美的，而且本博客只是介绍了单链表最为基础的部分，链表的知识不仅仅如此，还有很多需要我们去掌握和学习。好了，单链表的基础我们已经学完了，那么下一篇博客我们就可以尝试一下单链表的部分OJ题目了，希望本篇博客对大家有所帮助，我们下一篇博客再见！
扫一扫
4235
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
