AI 助理
备案控制台
开发者社区 人工智能 文章 正文

【数据结构】单链表---C语言版（全网最最最最细！小白必必必必看！！！有图有真相！）（二）

2023-09-08 68
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： 【数据结构】单链表---C语言版（全网最最最最细！小白必必必必看！！！有图有真相！）（二）

⭕接口7：头删（SLTPopFront）

🚨要注意头删有三种情况：1.没有结点（空链表）、2.一个结点、3.多个结点

链表为空不能头删，所以要进行assert断言

🥰请看代码与注释👇

//头删
void SLTPopFront(SLTNode** pphead)
{
  //没有结点(空链表)
  assert(*pphead);  //链表为空，不能头删
  assert(pphead);
  //一个结点
  if ((*pphead)->next == NULL)
  {
    free(*pphead);
    *pphead = NULL;
  }
  //多个结点
  else
  {
    SLTNode* cur = *pphead;
    *pphead = cur->next;
    free(cur);
  }
}

可以有更简洁高效的写法👇

🥰请看代码与注释👇

//头删
void SLTPopFront(SLTNode** pphead)
{
  //没有结点(空链表)
  assert(*pphead);
  assert(pphead);
  //一个结点
  //多个结点
  SLTNode* cur = *pphead;
  *pphead = (*pphead)->next;
  free(cur);
}

⭕接口8：尾删（SLTPopBack）

🚨要注意尾删同样有三种情况：1.没有结点（空链表）、2.一个结点、3.多个结点

链表为空不能尾删，所以要进行assert断言

🥰请看代码与注释👇

//尾删
void SLTPopBack(SLTNode** pphead)
{
  //没有结点(空链表)
  assert(*pphead);
  assert(pphead);
  //一个结点
  if ((*pphead)->next == NULL)
  {
    free(*pphead);
    *pphead = NULL;
  }
  //多个结点
  else
  {
    SLTNode* tail = *pphead;
    //找尾
    while (tail->next->next)
    {
      tail = tail->next;
    }
    free(tail->next);
    tail->next = NULL;
  }
}

⭕接口9：查找（SLTFind）

通过遍历进行查找，通常与修改结合联系使用

🥰请看代码与注释👇

//查找
SLTNode* SLTFind(SLTNode* phead, SLTDataType x)
{
  assert(phead);
  SLTNode* cur = phead;
  while (cur)
  {
    if (cur->data == x)
    {
      return cur;
    }
    else
    {
      cur = cur->next;
    }
  }
  return NULL;
}

⭕接口10：修改（SLTModify）

🥰请看代码与注释👇

//修改
void SLTModify(SLTNode* phead, SLTNode* pos, SLTDataType x)
{
  assert(phead);
  assert(pos);
  pos->data = x;
}

⭕接口11：在pos位置之前插入数据（SLTInsert）

🥰请看代码与注释👇

//在pos位置之前插入数据
void SLTInsert(SLTNode** pphead, SLTNode* pos, SLTDataType x)
{
  assert(pphead);
  assert(pos);  //防止给的位置为 空
  if (*pphead == pos)
  {
    SLTPushFront(pphead, x);
  }
  else
  {
    SLTNode* prev = *pphead;
    while (prev->next != pos)
    {
      prev = prev->next;
    }
    SLTNode* newnode = BuyLTNode(x);
    prev->next = newnode;
    newnode->next = pos;
  }
}

⭕接口12：在pos位置之后插入数据（SLTInsertAfter）

🥰请看代码与注释👇

//在pos位置之后插入数据
void SLTInsertAfter(SLTNode* pos, SLTDataType x)
{
  assert(pos);  //防止给的位置为 空
  SLTNode* newnode = BuyLTNode(x);
  newnode->next = pos->next;
  pos->next = newnode;
}

⭕接口13：删除pos位置的值（SLTErase）

🥰请看代码与注释👇

//删除pos位置的值
void SLTErase(SLTNode** pphead, SLTNode* pos)
{
  assert(pphead);
  assert(pos);  //防止给的位置为 空
  if (*pphead == pos)
  {
    SLTPopFront(pphead);
  }
  else
  {
    SLTNode* prev = *pphead;
    while (prev->next != pos)
    {
      prev = prev->next;
    }
    prev->next = pos->next;
    free(pos);
  }
}

⭕接口14：删除pos位置之后的值（SLTEraseAfter）

🥰请看代码与注释👇

//删除pos位置之后的值
void SLTEraseAfter(SLTNode* pos)
{
  assert(pos);
  assert(pos->next);
  SLTNode* next = pos->next;
  pos->next = next->next;
  free(next);
}

🐸四、完整代码

🥝SList.h

#pragma once
#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
//自定义类型
typedef int SLTDataType;
//创建单链表
typedef struct SListNode
{
  SLTDataType data;
  struct SListNode* next;
}SLTNode;
//打印
void SLTPrint(SLTNode* phead);
//释放
void SLTDestroy(SLTNode** pphead);
//创建新结点
SLTNode* BuyLTNode(SLTDataType x);
//头插
void SLTPushFront(SLTNode** pphead, SLTDataType x);
//尾插
void SLTPushBack(SLTNode** pphead, SLTDataType x);
//头删
void SLTPopFront(SLTNode** pphead);
//尾删
void SLTPopBack(SLTNode** pphead);
//查找
SLTNode* SLTFind(SLTNode* phead, SLTDataType x);
//修改
void SLTModify(SLTNode* phead, SLTNode* pos, SLTDataType x);
//在pos位置之前插入数据
void SLTInsert(SLTNode** pphead, SLTNode* pos, SLTDataType x);
//在pos位置之后插入数据
void SLTInsertAfter(SLTNode* pos, SLTDataType x);
//删除pos位置的值
void SLTErase(SLTNode** pphead, SLTNode* pos);
//删除pos位置之后的值
void SLTEraseAfter(SLTNode* pos);

🥝SList.c

#include"SList.h"
//打印
void SLTPrint(SLTNode* phead)
{
  SLTNode* cur = phead;
  while (cur != NULL)
  {
    printf("%d-> ", cur->data);
    cur = cur->next;
  }
  printf("NULL\n");
}
//释放
void SLTDestroy(SLTNode** pphead)
{
  assert(pphead);
  SLTNode* cur = *pphead;
  while (cur)
  {
    SLTNode* next = cur->next;
    free(cur);
    cur = next;
  }
  *pphead = NULL;
}
//创建新结点
SLTNode* BuyLTNode(SLTDataType x)
{
  SLTNode* newnode = (SLTNode*)malloc(sizeof(SLTNode));
  if (newnode == NULL)
  {
    perror("mallic fail");
    return;
  }
  newnode->data = x;
  newnode->next = NULL;
  return newnode;
}
//头插
void SLTPushFront(SLTNode** pphead, SLTDataType x)
{ 
  assert(pphead);   //链表为空，pphead也不为空，因为他是头指针plist的地址
                    // *pphead 不能断言，链表为空，也需要能插入
  SLTNode* newnode = BuyLTNode(x);
  newnode->next = *pphead;
  *pphead = newnode;
}
//尾插
void SLTPushBack(SLTNode** pphead, SLTDataType x)
{
  assert(pphead);
  SLTNode* newnode = BuyLTNode(x);
  //1.空链表
  //2.非空链表
  if (*pphead == NULL)
  {
    *pphead = newnode;    //改变的结构体的指针plist（用结构体指针的地址）
  }
  else
  {
    SLTNode* tail = *pphead;
    while (tail->next != NULL)
    {
      tail = tail->next;
    }
    tail->next = newnode;    //改变的结构体尾结点
  }
}
//头删
void SLTPopFront(SLTNode** pphead)
{
  //没有结点(空链表)
  assert(*pphead);  //链表为空，不能头删
  assert(pphead);
  //一个结点
  if ((*pphead)->next == NULL)
  {
    free(*pphead);
    *pphead = NULL;
  }
  //多个结点
  else
  {
    SLTNode* cur = *pphead;
    *pphead = cur->next;
    free(cur);
  }
}
//头删
//void SLTPopFront(SLTNode** pphead)
//{
//  //没有结点(空链表)
//  assert(*pphead);
//  assert(pphead);
//
//  //一个结点
//  //多个结点
//  SLTNode* cur = *pphead;
//  *pphead = (*pphead)->next;
//  free(cur);
//}
//尾删
void SLTPopBack(SLTNode** pphead)
{
  //没有结点(空链表)
  assert(*pphead);
  assert(pphead);
  //一个结点
  if ((*pphead)->next == NULL)
  {
    free(*pphead);
    *pphead = NULL;
  }
  //多个结点
  else
  {
    SLTNode* tail = *pphead;
    //找尾
    while (tail->next->next)
    {
      tail = tail->next;
    }
    free(tail->next);
    tail->next = NULL;
  }
}
//查找
SLTNode* SLTFind(SLTNode* phead, SLTDataType x)
{
  assert(phead);
  SLTNode* cur = phead;
  while (cur)
  {
    if (cur->data == x)
    {
      return cur;
    }
    else
    {
      cur = cur->next;
    }
  }
  return NULL;
}
//修改
void SLTModify(SLTNode* phead, SLTNode* pos, SLTDataType x)
{
  assert(phead);
  assert(pos);
  pos->data = x;
}
//在pos位置之前插入数据
void SLTInsert(SLTNode** pphead, SLTNode* pos, SLTDataType x)
{
  assert(pphead);
  assert(pos);  //防止给的位置为 空
  if (*pphead == pos)
  {
    SLTPushFront(pphead, x);
  }
  else
  {
    SLTNode* prev = *pphead;
    while (prev->next != pos)
    {
      prev = prev->next;
    }
    SLTNode* newnode = BuyLTNode(x);
    prev->next = newnode;
    newnode->next = pos;
  }
}
//在pos位置之后插入数据
void SLTInsertAfter(SLTNode* pos, SLTDataType x)
{
  assert(pos);  //防止给的位置为 空
  SLTNode* newnode = BuyLTNode(x);
  newnode->next = pos->next;
  pos->next = newnode;
}
//删除pos位置的值
void SLTErase(SLTNode** pphead, SLTNode* pos)
{
  assert(pphead);
  assert(pos);  //防止给的位置为 空
  if (*pphead == pos)
  {
    SLTPopFront(pphead);
  }
  else
  {
    SLTNode* prev = *pphead;
    while (prev->next != pos)
    {
      prev = prev->next;
    }
    prev->next = pos->next;
    free(pos);
  }
}
//删除pos位置之后的值
void SLTEraseAfter(SLTNode* pos)
{
  assert(pos);
  assert(pos->next);
  SLTNode* next = pos->next;
  pos->next = next->next;
  free(next);
}

🥝Test.c

#include"SList.h"
//头插测试
void TestSList01()
{
  SLTNode* plist = NULL;
  SLTPushFront(&plist, 1);
  SLTPushFront(&plist, 2);
  SLTPushFront(&plist, 3);
  SLTPushFront(&plist, 4);
  SLTPrint(plist);
  SLTDestroy(&plist);
}
//尾插测试
void TestSList02()
{
  SLTNode* plist = NULL;
  SLTPushFront(&plist, 1);
  SLTPushFront(&plist, 2);
  SLTPushFront(&plist, 3);
  SLTPushFront(&plist, 4);
  SLTPushBack(&plist, 5);
  SLTPushBack(&plist, 6);
  SLTPushBack(&plist, 7);
  SLTPrint(plist);
  SLTDestroy(&plist);
}
//头删测试
void TestSList03()
{
  SLTNode* plist = NULL;
  SLTPushFront(&plist, 1);
  SLTPushFront(&plist, 2);
  SLTPushFront(&plist, 3);
  SLTPushFront(&plist, 4);
  SLTPrint(plist);
  SLTPopFront(&plist);
  SLTPrint(plist);
  SLTPopFront(&plist);
  SLTPrint(plist);
  SLTPopFront(&plist);
  SLTPrint(plist);
  SLTPopFront(&plist);
  SLTPrint(plist);
  SLTDestroy(&plist);
}
//尾删测试
void TestSList04()
{
  SLTNode* plist = NULL;
  SLTPushFront(&plist, 1);
  SLTPushFront(&plist, 2);
  SLTPushFront(&plist, 3);
  SLTPushFront(&plist, 4);
  SLTPrint(plist);
  SLTPopBack(&plist);
  SLTPrint(plist);
  SLTPopBack(&plist);
  SLTPrint(plist);
  SLTPopBack(&plist);
  SLTPrint(plist);
  SLTPopBack(&plist);
  SLTPrint(plist);
  SLTDestroy(&plist);
}
//查找修改测试
void TestSList05()
{
  SLTNode* plist = NULL;
  SLTPushFront(&plist, 1);
  SLTPushFront(&plist, 2);
  SLTPushFront(&plist, 3);
  SLTPushFront(&plist, 4);
  SLTPrint(plist);
  SLTNode* pos = SLTFind(plist, 3);
  if (pos)
  {
    SLTModify(plist, pos, 8);
  }
  SLTPrint(plist);
  SLTDestroy(&plist);
}
//在pos位置之前插入数据测试
void TestSList06()
{
  SLTNode* plist = NULL;
  SLTPushFront(&plist, 1);
  SLTPushFront(&plist, 2);
  SLTPushFront(&plist, 3);
  SLTPushFront(&plist, 4);
  SLTPrint(plist);
  SLTNode* pos = SLTFind(plist, 3);
  if (pos)
  {
    SLTInsert(&plist, pos, 30);
  }
  SLTPrint(plist);
  SLTDestroy(&plist);
}
//在pos位置之后插入数据测试
void TestSList07()
{
  SLTNode* plist = NULL;
  SLTPushFront(&plist, 1);
  SLTPushFront(&plist, 2);
  SLTPushFront(&plist, 3);
  SLTPushFront(&plist, 4);
  SLTPrint(plist);
  SLTNode* pos = SLTFind(plist, 2);
  if (pos)
  {
    SLTInsertAfter(pos, 20);
  }
  SLTPrint(plist);
  SLTDestroy(&plist);
}
//删除pos位置的值测试
void TestSList08()
{
  SLTNode* plist = NULL;
  SLTPushFront(&plist, 1);
  SLTPushFront(&plist, 2);
  SLTPushFront(&plist, 3);
  SLTPushFront(&plist, 4);
  SLTPrint(plist);
  SLTNode* pos = SLTFind(plist, 3);
  if (pos)
  {
    SLTErase(&plist,pos);
  }
  SLTPrint(plist);
  SLTDestroy(&plist);
}
//删除pos位置之后的值测试
void TestSList09()
{
  SLTNode* plist = NULL;
  SLTPushFront(&plist, 1);
  SLTPushFront(&plist, 2);
  SLTPushFront(&plist, 3);
  SLTPushFront(&plist, 4);
  SLTPrint(plist);
  SLTNode* pos = SLTFind(plist, 2);
  if (pos)
  {
    SLTEraseAfter(pos);
  }
  SLTPrint(plist);
  SLTDestroy(&plist);
}
int main()
{
  //TestSList01();
  //TestSList02();
  //TestSList03();
  //TestSList04();
  //TestSList05();
  //TestSList06();
  //TestSList07();
  //TestSList08();
  //TestSList09();
  return 0;
}

😍这期内容些许复杂，需要慢慢理解消化哦！

总结🥰
以上就是 【数据结构】单链表—C语言版 的全部内容啦🥳🥳🥳🥳
本文章所在【数据结构与算法】专栏，感兴趣的烙铁可以订阅本专栏哦🥳🥳🥳
前途很远，也很暗，但是不要怕，不怕的人面前才有路。💕💕💕
小的会继续学习，继续努力带来更好的作品😊😊😊
创作写文不易，还多请各位大佬uu们多多支持哦🥰🥰🥰

文章标签：
算法
关键词：
C语言数据结构
数据结构c语言
数据结构单链表
C语言单链表
数据结构最最
C-调战士
目录
相关文章
土木林森
|
17天前
|
算法 数据处理 C语言
C语言中的位运算技巧，涵盖基本概念、应用场景、实用技巧及示例代码，并讨论了位运算的性能优势及其与其他数据结构和算法的结合
本文深入解析了C语言中的位运算技巧，涵盖基本概念、应用场景、实用技巧及示例代码，并讨论了位运算的性能优势及其与其他数据结构和算法的结合，旨在帮助读者掌握这一高效的数据处理方法。
土木林森
28 1
XIAZHI
|
26天前
|
存储 算法 搜索推荐
【趣学C语言和数据结构100例】91-95
本文涵盖多个经典算法问题的C语言实现，包括堆排序、归并排序、从长整型变量中提取偶数位数、工人信息排序及无向图是否为树的判断。通过这些问题，读者可以深入了解排序算法、数据处理方法和图论基础知识，提升编程能力和算法理解。
XIAZHI
42 4
XIAZHI
|
26天前
|
存储 机器学习/深度学习 搜索推荐
【趣学C语言和数据结构100例】86-90
本文介绍并用C语言实现了五种经典排序算法：直接插入排序、折半插入排序、冒泡排序、快速排序和简单选择排序。每种算法都有其特点和适用场景，如直接插入排序适合小规模或基本有序的数据，快速排序则适用于大规模数据集，具有较高的效率。通过学习这些算法，读者可以加深对数据结构和算法设计的理解，提升解决实际问题的能力。
XIAZHI
39 4
XIAZHI
|
26天前
|
存储 算法 数据处理
【趣学C语言和数据结构100例】81-85
本文介绍了五个经典算法问题及其C语言实现，涵盖图论与树结构的基础知识。包括使用BFS求解单源最短路径、统计有向图中入度或出度为0的点数、统计无向无权图各顶点的度、折半查找及二叉排序树的查找。这些算法不仅理论意义重大，且在实际应用中极为广泛，有助于提升编程能力和数据结构理解。
XIAZHI
36 4
XIAZHI
|
26天前
|
算法 数据可视化 数据建模
【趣学C语言和数据结构100例】76-80
本文介绍了五种图论算法的C语言实现，涵盖二叉树的层次遍历及广度优先搜索（BFS）和深度优先搜索（DFS）的邻接表与邻接矩阵实现。层次遍历使用队列按层访问二叉树节点；BFS利用队列从源节点逐层遍历图节点，适用于最短路径等问题；DFS通过递归或栈深入图的分支，适合拓扑排序等场景。这些算法是数据结构和算法学习的基础，对提升编程能力和解决实际问题至关重要。
XIAZHI
41 4
龙大吉
|
19天前
|
存储 缓存 算法
在C语言中，数据结构是构建高效程序的基石。本文探讨了数组、链表、栈、队列、树和图等常见数据结构的特点、应用及实现方式
在C语言中，数据结构是构建高效程序的基石。本文探讨了数组、链表、栈、队列、树和图等常见数据结构的特点、应用及实现方式，强调了合理选择数据结构的重要性，并通过案例分析展示了其在实际项目中的应用，旨在帮助读者提升编程能力。
龙大吉
42 5
土木林森
|
17天前
|
并行计算 算法 测试技术
C语言因高效灵活被广泛应用于软件开发。本文探讨了优化C语言程序性能的策略，涵盖算法优化、代码结构优化、内存管理优化、编译器优化、数据结构优化、并行计算优化及性能测试与分析七个方面
C语言因高效灵活被广泛应用于软件开发。本文探讨了优化C语言程序性能的策略，涵盖算法优化、代码结构优化、内存管理优化、编译器优化、数据结构优化、并行计算优化及性能测试与分析七个方面，旨在通过综合策略提升程序性能，满足实际需求。
土木林森
46 1
這～悸ベ雨落憂殇
|
存储 缓存 C语言
数据结构——双链表（C语言）
数据结构——双链表（C语言）
這～悸ベ雨落憂殇
48 0
ephemerals__
|
1月前
|
存储 C语言
【数据结构】手把手教你单链表（c语言）（附源码）
本文介绍了单链表的基本概念、结构定义及其实现方法。单链表是一种内存地址不连续但逻辑顺序连续的数据结构，每个节点包含数据域和指针域。文章详细讲解了单链表的常见操作，如头插、尾插、头删、尾删、查找、指定位置插入和删除等，并提供了完整的C语言代码示例。通过学习单链表，可以更好地理解数据结构的底层逻辑，提高编程能力。
ephemerals__
71 4
ephemerals__
|
1月前
|
C语言
【数据结构】双向带头循环链表（c语言）（附源码）
本文介绍了双向带头循环链表的概念和实现。双向带头循环链表具有三个关键点：双向、带头和循环。与单链表相比，它的头插、尾插、头删、尾删等操作的时间复杂度均为O(1)，提高了运行效率。文章详细讲解了链表的结构定义、方法声明和实现，包括创建新节点、初始化、打印、判断是否为空、插入和删除节点等操作。最后提供了完整的代码示例。
ephemerals__
49 0