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

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

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

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

单链表

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

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;
}

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


关键词：
数据结构链表
数据结构循环链表
数据结构单链表
数据结构单向
数据结构单链表循环链表
卫卫周大胖
目录
相关文章
XIAZHI
|
1月前
|
存储 算法 Perl
数据结构实验之链表
本实验旨在掌握线性表中元素的前驱、后续概念及链表的建立、插入、删除等算法，并分析时间复杂度，理解链表特点。实验内容包括循环链表应用（约瑟夫回环问题）、删除单链表中重复节点及双向循环链表的设计与实现。通过编程实践，加深对链表数据结构的理解和应用能力。
XIAZHI
62 4
三三是该溜子
|
5天前
|
数据库
数据结构中二叉树，哈希表，顺序表，链表的比较补充
二叉搜索树，哈希表，顺序表，链表的特点的比较
三三是该溜子
18 0
数据结构中二叉树，哈希表，顺序表，链表的比较补充
龙大吉
|
1月前
|
存储 缓存 算法
在C语言中，数据结构是构建高效程序的基石。本文探讨了数组、链表、栈、队列、树和图等常见数据结构的特点、应用及实现方式
在C语言中，数据结构是构建高效程序的基石。本文探讨了数组、链表、栈、队列、树和图等常见数据结构的特点、应用及实现方式，强调了合理选择数据结构的重要性，并通过案例分析展示了其在实际项目中的应用，旨在帮助读者提升编程能力。
龙大吉
58 5
XIAZHI
|
1月前
|
算法
数据结构之购物车系统(链表和栈)
本文介绍了基于链表和栈的购物车系统的设计与实现。该系统通过命令行界面提供商品管理、购物车查看、结算等功能，支持用户便捷地管理购物清单。核心代码定义了商品、购物车商品节点和购物车的数据结构，并实现了添加、删除商品、查看购物车内容及结算等操作。算法分析显示，系统在处理小规模购物车时表现良好，但在大规模购物车操作下可能存在性能瓶颈。
XIAZHI
50 0
ephemerals__
|
1月前
|
C语言
【数据结构】双向带头循环链表（c语言）（附源码）
本文介绍了双向带头循环链表的概念和实现。双向带头循环链表具有三个关键点：双向、带头和循环。与单链表相比，它的头插、尾插、头删、尾删等操作的时间复杂度均为O(1)，提高了运行效率。文章详细讲解了链表的结构定义、方法声明和实现，包括创建新节点、初始化、打印、判断是否为空、插入和删除节点等操作。最后提供了完整的代码示例。
ephemerals__
73 0
ephemerals__
|
1月前
|
C语言
【数据结构】栈和队列（c语言实现）（附源码）
本文介绍了栈和队列两种数据结构。栈是一种只能在一端进行插入和删除操作的线性表，遵循“先进后出”原则；队列则在一端插入、另一端删除，遵循“先进先出”原则。文章详细讲解了栈和队列的结构定义、方法声明及实现，并提供了完整的代码示例。栈和队列在实际应用中非常广泛，如二叉树的层序遍历和快速排序的非递归实现等。
ephemerals__
225 9
那年春天
|
1月前
|
存储 算法
非递归实现后序遍历时，如何避免栈溢出？
后序遍历的递归实现和非递归实现各有优缺点，在实际应用中需要根据具体的问题需求、二叉树的特点以及性能和空间的限制等因素来选择合适的实现方式。
那年春天
37 1
德国都芳最好
|
1月前
|
存储 算法 Java
数据结构的栈
栈作为一种简单而高效的数据结构，在计算机科学和软件开发中有着广泛的应用。通过合理地使用栈，可以有效地解决许多与数据存储和操作相关的问题。
德国都芳最好
90 21
html的七十二变
|
1月前
|
存储 JavaScript 前端开发
执行上下文和执行栈
执行上下文是JavaScript运行代码时的环境，每个执行上下文都有自己的变量对象、作用域链和this值。执行栈用于管理函数调用，每当调用一个函数，就会在栈中添加一个新的执行上下文。
html的七十二变
35 2
dufadayang
|
1月前
|
存储
系统调用处理程序在内核栈中保存了哪些上下文信息？
【10月更文挑战第29天】系统调用处理程序在内核栈中保存的这些上下文信息对于保证系统调用的正确执行和用户程序的正常恢复至关重要。通过准确地保存和恢复这些信息，操作系统能够实现用户模式和内核模式之间的无缝切换，为用户程序提供稳定、可靠的系统服务。
dufadayang
52 4

热门文章

最新文章

  • 1
    Python编程数据结构的深入理解
  • 2
    掌握Pandas核心数据结构：Series与DataFrame的四种创建方式
  • 3
    K-means聚类算法是机器学习中常用的一种聚类方法，通过将数据集划分为K个簇来简化数据结构
  • 4
    Python 中的数据结构与其他编程语言数据结构的区别
  • 5
    C语言因高效灵活被广泛应用于软件开发。本文探讨了优化C语言程序性能的策略，涵盖算法优化、代码结构优化、内存管理优化、编译器优化、数据结构优化、并行计算优化及性能测试与分析七个方面
  • 6
    Python 中的数据结构和算法优化策略
  • 7
    Python 中数据结构和算法的关系
  • 8
    探索局域网电脑监控软件：Python算法与数据结构的巧妙结合
  • 9
    Pandas数据结构：Series与DataFrame
  • 10
    C语言中的位运算技巧，涵盖基本概念、应用场景、实用技巧及示例代码，并讨论了位运算的性能优势及其与其他数据结构和算法的结合
  • 1
    链表遍历，链表查找和统计节点，链表插入新节点，链表删除节点，链表修改指定节点,链表头插法，尾插法总结
    49
  • 2
    剑指offer（牛客）——合并两个排序的链表
    48
  • 3
    剑指offer（牛客）——从尾到头打印链表
    44
  • 4
    每日一题：力扣328. 奇偶链表
    53
  • 5
    数据结构与算法 数组和链表
    49
  • 6
    leetcode代码记录（移除链表元素
    36
  • 7
    单链表的应用
    63
  • 8
    数据结构第二课 -----线性表之单向链表
    61
  • 9
    数据结构第三课 -----线性表之双向链表
    52
  • 10
    链表练习题-2
    55

    • 相关课程

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

    • 相关电子书

    更多
  • 如何使用Tair增强数据结构构建丰富在线实时场景
  • Apache Flink 流式应用中状态的数据结构定义升级
  • 低代码开发师（初级）实战教程
    • 下一篇
    手把手教你白嫖阿里云服务器(免费领服务器)