AI 助理
备案控制台
开发者社区 云计算 文章 正文

【数据结构】单链表之--无头单向非循环链表

2024-03-12 41
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： 【数据结构】单链表之--无头单向非循环链表

前言：前面我们学习了动态顺序表并且模拟了它的实现，今天我们来进一步学习，来学习单链表！一起加油各位，后面的路只会越来越难走需要我们一步一个脚印！

单链表

今天我们要实现的全部功能就如下所示，功能很多我们一步一步来，一起来手撕链表吧！加油！

typedef int SLNDataType;

typedef struct SList
{
  int val;
  struct SList* next;
}SLNode;

//单链表的打印
void SLTPrint(SLNode* phead);

//单链表的尾插
void SLTPushBack(SLNode** pphead, SLNDataType x);

//单链表的头插
void SLTPushFront(SLNode** pphead, SLNDataType x);

//单链表的尾删
void SLTPopback(SLNode** pphead);

//单链表的头删
void SLTPopFront(SLNode** pphead);

//单链表的元素查找
SLNode* SLFind(SLNode* phead, SLNDataType x);

//单链表的插入-在pos的前面插入
SLNode* SLInsert(SLNode** pphead,SLNode* pos, SLNDataType x);//需要自己思考一级还是二级

//单链表的删除
void SLTErase(SLNode** pphead, SLNode* pos);


//单链表的销毁
void SLTDestroy(SLNode** pphead);


//单链表的删除-pos之后的元素
void SLTEraseAfter(SLNode* pos,SLNDataType x);

//单链表插入-pos之后插入
void SLTInsertAfter(SLNode* pos,SLNDataType x);

动态申请一个结点

代码思路，首先我们要开辟一个结构体，来开始我们今天的单链表

typedef struct SList
{
  int val;
  struct SList* next;
}SLNode;

当然了，我们肯定得写一个接口，来申请动态开辟的一个结点(这个我们在前面写顺序表的时候就写过了，就不过多介绍这个了)，可以看下图帮助自己理解 

SLNode* CreateNewNode(SLNDataType x)//开辟一个新的节点
{
  SLNode* newnode = (SLNode*)malloc(sizeof(SLNode));
  if (newnode == NULL)//判断是否有空间
  {
    perror("malloc fail");
    exit(-1);
  }
  newnode->val = x;
  newnode->next = NULL;
  return newnode;
}

单链表的打印

代码思路：单链表中我们可以知道它是如下图这种形式，每一个结构体中存着下个节点的地址，我们可以通过判断结构体指针是否为空指针来依次打印

void SLTPrint(SLNode* phead)
{
  SLNode* cur = phead;//通过头节点依次访问
  while (cur != NULL)
  {
    printf("%d->", cur->val);
    cur = cur->next;
  }
  printf("NULL\n");
}

单链表的尾插

在写代码之前，我们需要重新复习一下，对形参的修改不会改变实参,形参是实参的一个临时拷贝（请牢牢记住，后面有很大的作用），这在后面帮助我们理解单链表有很大的帮助。

我们先来看一串代码

void swap(int* a, int* b)
{
  int tmp = 0;
  tmp = *a;
  *a = *b;
  *b = tmp;
}

int main()
{
  int a = 3;
  int b = 5;
  swap(&a, &b);
  printf("a = %d,b = %d", a, b);
  return 0;
}

我们要想改变

void swap(int** a, int** b)
{
  int tmp = 0;
  tmp = **a;
  **a = **b;
  **b = tmp;
}

int main()
{
  int arr1[] = { 1 };
  int arr2[] = { 2 };
  int* a = arr1;
  int* b = arr2;
  swap(&a, &b); 
  printf("*a = %d, *b = %d",*a, *b);
  return 0;
}

由这些可以知道，我们要想修改一级指针里面的值，我们要用二级指针接收。接下来我们就开始上我们的第一盘凉菜了！

代码思路：首先我们肯定要考虑两种情况，即一种是链表是空的什么都没有，另一种即链表中有值，需要我们尾增新的值，我们可以借助下图来帮助我们分析！我们通过循环找到该链表的尾结点，然后让尾部结点中的next，假如链表中没有值是空链表，我们直接指向新的结点即可。

void SLTPushBack(SLNode** pphead, SLNDataType x)//尾插节点
{
  assert(pphead);//判断传过来的链表是否存在

  SLNode* newnode = CreateNewNode(x);//开辟节点
  if (*pphead == NULL)//判断传来的是否是空指针，如果为空就直接开辟新的节点
  {
    *pphead = newnode;
  }
  else
  {
    SLNode* tail = *pphead;
    while (tail->next != NULL)//只有尾结点的next才是空
    {
      tail = tail->next;//找到尾节点
    }
    tail->next = newnode;//将为节点的值指向新节点
  }
}

这里大家肯定会有很多疑问，为什么是 **phead ,我们来看下图

函数测试与结果运行图：

void Test1()
{
  SLNode* plist = NULL;
  SLTPushBack(&plist, 1);//尾插
  SLTPushBack(&plist, 2);
  SLTPushBack(&plist, 3);
  SLTPushBack(&plist, 4);
  SLTPrint(plist);
}


int main()
{
  Test1();
  return 0;
}

单链表的头插

代码思路：单链表的头插我们依然得借助图像来帮助我们分析如下图，我们让*phead指向newnode开辟的结点，在让newnode->next指向原本的头结点即可完成头插，当然我们依然得用二级指针接收，因为我们要修改的一级指针。

代码实现：

void SLTPushFront(SLNode** pphead, SLNDataType x)//单链表的头插
{
  assert(pphead);
  SLNode* newnode = CreateNewNode(x);//开辟一个新的节点
  newnode->next = *pphead;//将头节点地址存放在next中
  *pphead = newnode;  //在让头节点指向Newnode，此时newnode就称为了头节点
}

函数测试与效果图：

void Test2()
{
  SLNode* plist = NULL;
  SLTPushFront(&plist, 2);//头插
  SLTPushFront(&plist, 2);
  SLTPushFront(&plist, 9);
  SLTPrint(plist);
}

int main()
{
  //Test1();
  Test2();
  return 0;
}

单链表的尾删

思路分析：在单链表的尾部删除中，我们需要考虑两种情况一种为单节点，一种为多节点，即一种删除完后链表中的值为空，另一种即删除最后一个后仍然还有结点。当然了，我们依然得先画图分析，如下图。我们看图一，可以知道，我们直接找到 *phead这个结点将他free掉即可，然后将 *phead置为空指针，即可完成单结点的删除。我们看图二，我们得找到一个尾结点将它释放，将尾部结点的前一个结点中的next即保留最后一个结点中的地址，让它置为空指针即删除完毕，由此我们可以通过一个快慢指针，一个指针往后走，一个保留前一个结点的地址，因此我们可以找到最后一个结点并保留前一个结点的地址。


代码思路：

void SLTPopback(SLNode** pphead)//单链表的尾删
{
  //一个节点
  //多个节点
  assert(pphead);
  assert(*pphead);
  if ((*pphead)->next == NULL)//单节点
  {
    free(*pphead);//释放pphead所在的空间
    *pphead = NULL;//将pphead置为空指针
  }
  else//多节点
  {
    SLNode* tail = *pphead;//铜鼓快慢指针来找到节点
    SLNode* prev = NULL;
    while (tail->next != NULL)//找到尾节点
    {
      //倒数第一步(尾节点的前一个节点时)
      prev = tail;//此时prev就是记录后一个节点的地址
      tail = tail->next;//此时找到了NULL
    }
    free(tail);//释放掉记录尾结点的地址
    prev->next = NULL;//将此时赋值为NULL即删除成功
  }
}

函数测试与运行结果：

void Test3()
{
  SLNode* plist = NULL;
  printf("打印删除之前的\n");
  SLTPushFront(&plist, 2);//头增
  SLTPushFront(&plist, 2);
  SLTPushFront(&plist, 9);
  SLTPrint(plist);
  printf("打印删除之后的\n");
  SLTPopback(&plist);//尾删
  SLTPopback(&plist);
  SLTPrint(plist);
}

int main()
{
  //Test1();
  //Test2();
  Test3();
  return 0;
}

单链表的头删

思路分析:实现头删，我们就是把头部中的空间free掉,在将 *phead指向原本的第二个节点即可，因此我们需要用一个结构体指针指向第二个节点将其保留下来传给原本的头指针。可以通过下图帮助自己分析，如下图。

代码思路实现：

void SLTPopFront(SLNode** pphead)//头删
{
  //空
  assert(pphead);
  //多个节点
  SLNode* tmp = (*pphead)->next;
  free(*pphead);
  *pphead = tmp;  
}

测试函数与运行结果：

void Test4()
{
  SLNode* plist = NULL;
  printf("打印删除之前的\n");
  SLTPushFront(&plist, 2);//尾增
  SLTPushFront(&plist, 2);
  SLTPushFront(&plist, 9);
  SLTPrint(plist);
  printf("打印删除之后的\n");
  SLTPopFront(&plist);//头删
  SLTPopFront(&plist);
  SLTPrint(plist);
}
int main()
{
  //Test1();
  //Test2();
  //Test3();
  Test4();
  return 0;
}

单链表的数值查找

思路分析：我们可以通过指针去一次遍历链表中的数据，找到对应值即找到了，返回此时指针的地址，遍历到最后一个NULL也没有找到时，即返回空指针，如下图

代码实现:

SLNode* SLFind(SLNode* phead, SLNDataType x)//查找
{
  assert(phead);
  SLNode* tail = phead;
  while (tail)
  {
    if(tail->val == x)
    {
      return tail;//返回此时指针的值
    }
    tail = tail->next;
  }
  return NULL;
}


函数测试与效果图：

void Test5()
{
  SLNode* plist = NULL;
  printf("打印删除之前的\n");
  SLTPushFront(&plist, 2);//尾增
  SLTPushFront(&plist, 2);
  SLTPushFront(&plist, 9);
  SLTPrint(plist);
  printf("查找结果:\n");
  printf("%p\n",SLFind(plist, 2));//查找数
  printf("%p\n", SLFind(plist, 99));
}
int main()
{
  //Test1();
  //Test2();
  //Test3();
  //Test4();
  Test5();
  return 0;
}


单链表的插入- 在pos的前面插入

思路分析：如果是多节点要想实现在pos的前面插入，首先我们要找到pos的前面一个节点让它指向我们新开辟的节点newnode然后再让newnode->next指向我们原本pos的所在的节点就完成了头插，如下图1所示。如果是单节点的时候，就是相当于头插，我们只需要判断是否是单节点，如果是就直接调用头插函数即可。

代码实现：

SLNode* SLInsert(SLNode** pphead, SLNode* pos, SLNDataType x)//单链表插入
{
  assert(pphead);
  assert(pos);
  assert(*pphead);
  //单节点
  if (*pphead == pos)
  {
    //头插
    SLTPushFront(pphead, x);
  }
  else
  {
    //多节点
    SLNode* tail = *pphead;
    SLNode* newnode = CreateNewNode(x);
    while (tail->next != pos)
    {
      tail = tail->next;
    }
    tail->next = newnode;
    newnode->next = pos;
  }
}

函数测试与效果图：

void Test6()
{
  SLNode* plist = NULL;
  printf("原本的值\n");
  SLTPushFront(&plist, 2);//尾增
  SLTPushFront(&plist, 2);
  SLTPushFront(&plist, 9);
  SLTPrint(plist);
  printf("插入之后的结果\n");
  SLNode* address = SLFind(plist, 2);//查找数
  SLInsert(&plist, address, 10);
  SLTPrint(plist);
}
int main()
{
  //Test1();
  //Test2();
  //Test3();
  //Test4();
  //Test5();
  Test6();
  return 0;
}

单链表数值的删除-删除Pos前的值

思路分析：当然了单链表的删除我们依然得采用俩种情况，一种情况为单节点，一种情况为多节点，我们先来分析多节点，如果是多节点的情况，我们应当找到pos的节点将它释放掉，并且我们应当将pos的前一个节点将他记录下来，并让它指向pos之后的一个节点，此时我们即可完成数值的删除。如下图所示，如果是单节点的情况，我们可以直接当成头删，直接调用头删函数即可。

代码实例：

void SLTErase(SLNode** pphead, SLNode* pos)//数值的删除
{
  assert(pphead);//判断传来的结构体是否存在
  assert(*pphead);//判断是否为空指针
  assert(pos);//判断空地址
  if (*pphead == pos)
  {
    SLTPopFront(pphead);//头删
  }
  else
  {
    SLNode* tail = *pphead;
    while (tail->next != pos)
    {
      tail = tail->next;
    }
    tail->next = pos->next;
    free(pos);
    pos = NULL;
  }
}

函数测试与效果图：

void Test7()
{
  SLNode* plist = NULL;
  printf("原本的值\n");
  SLTPushFront(&plist, 2);//尾增
  SLTPushFront(&plist, 3);
  SLTPushFront(&plist, 2);
  SLTPushFront(&plist, 9);
  SLTPrint(plist);
  printf("删除之后的结果\n");
  SLNode* address = SLFind(plist, 2);//查找数
  SLTErase(&plist, address);
  SLTPrint(plist);
}
int main()
{
  //Test1();
  //Test2();
  //Test3();
  //Test4();
  //Test5();
  //Test6();
  Test7();
  return 0;
}

单链表的销毁

思路分析：要想销毁单链表中的所有值，我们只需要把单链表中的每个节点给它释放，并最后让头节点指向空指针即可，因此我们需要借助两个指针，一个指针指向tail的下一个节点，当释放掉tail后让tail可以指向下一个节点再依次释放，这样就可以达到链表的销毁的作用，如下图所示。

代码实例：

void SLTDestroy(SLNode** pphead)//单链表的销毁
{
  assert(*pphead);//判断传来的是否已经是空指针
  SLNode* tail = *pphead;
  SLNode* pre = NULL;
  while (tail != NULL)//找到尾节点
  {
    pre = tail->next;
    free(tail);//依次释放
    tail = pre;
  }
  *pphead = NULL;
}

函数测试与效果图:

void Test8()
{
  SLNode* plist = NULL;
  printf("原本的值\n");
  SLTPushFront(&plist, 2);//尾增
  SLTPushFront(&plist, 3);
  SLTPushFront(&plist, 2);
  SLTPushFront(&plist, 9);
  SLTPrint(plist);
  printf("删除之后的结果\n");
  SLTDestroy(&plist);
  SLTPrint(plist);
}

int main()
{
  //Test1();
  //Test2();
  //Test3();
  //Test4();
  //Test5();
  //Test6();
  Test8();
  return 0;
}

结语：今天的内容就到这里吧，谢谢各位的观看，如果有讲的不好的地方也请各位多多指出，作者每一条评论都会读的，谢谢各位。


关键词：
数据结构链表
数据结构循环链表
数据结构单链表
数据结构单向
数据结构单链表循环链表
卫卫周大胖
目录
相关文章
java冯坚持
|
23天前
|
算法 程序员 索引
数据结构与算法学习七：栈、数组模拟栈、单链表模拟栈、栈应用实例 实现 综合计算器
栈的基本概念、应用场景以及如何使用数组和单链表模拟栈，并展示了如何利用栈和中缀表达式实现一个综合计算器。
java冯坚持
24 1
数据结构与算法学习七：栈、数组模拟栈、单链表模拟栈、栈应用实例 实现 综合计算器
白子寰
|
18天前
|
存储
[数据结构] -- 单链表
[数据结构] -- 单链表
白子寰
20 1
ephemerals__
|
3天前
|
C语言
【数据结构】双向带头循环链表（c语言）（附源码）
本文介绍了双向带头循环链表的概念和实现。双向带头循环链表具有三个关键点：双向、带头和循环。与单链表相比，它的头插、尾插、头删、尾删等操作的时间复杂度均为O(1)，提高了运行效率。文章详细讲解了链表的结构定义、方法声明和实现，包括创建新节点、初始化、打印、判断是否为空、插入和删除节点等操作。最后提供了完整的代码示例。
ephemerals__
13 0
努力学习的小廉
|
27天前
|
存储
【数据结构】——单链表实现
【数据结构】——单链表实现
努力学习的小廉
24 2
徐霞客320
|
29天前
|
存储
数据结构2——单链表
数据结构2——单链表
徐霞客320
31 1
星霜旅人
|
17天前
|
存储
数据结构（单链表）
数据结构（单链表）
星霜旅人
9 0
java冯坚持
|
23天前
|
算法 Java
数据结构与算法学习六：单向环形链表应用实例的约瑟夫环问题
这篇文章通过单向环形链表的应用实例，详细讲解了约瑟夫环问题的解决方案，并提供了Java代码实现。
java冯坚持
15 0
GuGuStudy
|
25天前
数据结构的带头，双向，循环链表来咯
数据结构的带头，双向，循环链表来咯
GuGuStudy
13 0
平凡程序猿~
|
30天前
|
存储
数据结构--单链表
数据结构--单链表
平凡程序猿~
14 0
数据分析螺丝钉
|
5月前
|
存储 SQL 算法
LeetCode力扣第114题：多种算法实现 将二叉树展开为链表
LeetCode力扣第114题：多种算法实现 将二叉树展开为链表
数据分析螺丝钉
41 0

热门文章

最新文章

  • 1
    数据结构~在页面上渲染树型结构
  • 2
    我花了一夜用数据结构给女朋友写个H5走迷宫游戏
  • 3
    基于OHCI的USB主机 —— OHCI（自定义数据结构）
  • 4
    数据结构学习笔记【持续更新】
  • 5
    学数据结构，只需要基本的编程体验
  • 6
    算法导论第十四章 数据结构的扩张
  • 7
    数据结构之堆的应用
  • 8
    [数据结构 -- C语言] 堆(Heap)，你小子就是堆，看我如何透彻的将你拿捏
  • 9
    大数据开发基础的数据结构和算法的数据结构的图
  • 10
    【数据结构与算法】—— * 深度优先搜索入门 *
  • 1
    关于带环链表的结论
    26
  • 2
    数据结构链表详解(不仅顺序表可以，我链表也可以)
    36
  • 3
    链表的头插法和尾插法
    216
  • 4
    序表和链表的区别（通俗易懂）
    50
  • 5
    特殊链表（循环单链表，循环双链表，静态链表）
    49
  • 6
    双链表的插入，删除以及遍历
    45
  • 7
    实现双向链表的运势解读
    34
  • 8
    实现双向链表计算运势
    35
  • 9
    链表遍历，链表查找和统计节点，链表插入新节点，链表删除节点，链表修改指定节点,链表头插法，尾插法总结
    37
  • 10
    剑指offer（牛客）——合并两个排序的链表
    36

    • 相关课程

    更多
  • Go语言核心编程 - 数据结构和算法

    • 相关电子书

    更多
  • 如何使用Tair增强数据结构构建丰富在线实时场景
  • Apache Flink 流式应用中状态的数据结构定义升级
  • 低代码开发师（初级）实战教程
    • 下一篇
    阿里云无影云电脑免费试用，最长可试用3个月