链表——单链表的C实现（保姆级代码、注释教学）

首先需要借助三个文件        SList.h        SList.c        test.c

目录

SList.h ：用来建立结构体、头文件、函数声明、全局变量建立

SList.c：对头文件中声明的函数的实现

void SLTPrint(SLTNode* phead)

SLTNode* BuyLTNode(SLTDataType x)

void SLPushFront(SLTNode** pphead, SLTDataType x)

//void SLPushBack(SLTNode* phead, SLTDataType x)

void SLPushBack(SLTNode** pphead, SLTDataType x)  //尾部需要用tail

void SLPopFront(SLTNode** pphead)   //头删

void SLPopBack(SLTNode** pphead)

SLTNode* STFind(SLTNode* phead, SLTDataType x)    //查找会返回当前节点的指针，所以如果查找不为空，可以直接进行修改

void SLInsert(SLTNode** pphead, SLTNode* pos, SLTDataType x)     //pos是某个节点的指针 //前插需要pphead，后插不需要（前插需要判断pos是不是首元素！）

void SLInsertAfter(SLTNode* pos, SLTDataType x)           //find之后，会返回当前的指针，传给pos使用

void SLErase(SLTNode** pphead, SLTNode* pos)              //前删需要pphead，后删不需要  需要判断pos是不是首元素！

void SLEraseAfter(SLTNode* pos)            //传找到的一级指针就可以

test.c

值得一提的是

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 SLPushFront(SLTNode** pphead, SLTDataType x);
void SLPushBack(SLTNode** pphead, SLTDataType x);

void SLPopFront(SLTNode** pphead);
void SLPopBack(SLTNode** pphead);

// 单链表查找
SLTNode* STFind(SLTNode* phead, SLTDataType x);

// 在pos之前插入
void SLInsert(SLTNode** pphead, SLTNode* pos, SLTDataType x);
void SLInsertAfter(SLTNode* pos, SLTDataType x);

// 删除pos位置的值
void SLErase(SLTNode** pphead, SLTNode* pos);

// 删除pos位置后面的值
void SLEraseAfter(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");

}

SLTNode* BuyLTNode(SLTDataType x)

{

       SLTNode* newnode = (SLTNode*)malloc(sizeof(SLTNode));

       if (newnode == NULL)

       {

              perror("malloc fail");

              return NULL;

       }

       newnode->data = x;

       newnode->next = NULL;

       return newnode;

}

void SLPushFront(SLTNode** pphead, SLTDataType x)

{

       assert(pphead);  // 链表为空，pphead也不为空，因为他是头指针plist的地址          //pphead 要断言 ， 因为需要对 pphead 进行解引用操作并修改 *pphead  =  ....

       //assert(*pphead); // 不能断言，     链表为空，也需要能插入 //因为 *pphead 不需要再次解引

       SLTNode* newnode = BuyLTNode(x);

       newnode->next = *pphead;

       *pphead = newnode;

}

//void SLPushBack(SLTNode* phead, SLTDataType x)

//{

//     SLTNode* tail = phead;

//     while (tail != NULL)

//     {

//            tail = tail->next;

//     }

//

//     SLTNode* newnode = BuyLTNode(x);

//     tail = newnode;

//}

void SLPushBack(SLTNode** pphead, SLTDataType x)  //尾部需要用tail

{

       assert(pphead); // 链表为空，pphead也不为空，因为他是头指针plist的地址

       //assert(*pphead); // 链表为空，可以尾插

       SLTNode* newnode = BuyLTNode(x);

       // 1、空链表

       // 2、非空链表

       if (*pphead == NULL)

       {

              *pphead = newnode;

       }

       else

       {

              SLTNode* tail = *pphead;

              while (tail->next != NULL)

              {

                      tail = tail->next;

              }

              tail->next = newnode;

       }

}

void SLPopFront(SLTNode** pphead)   //头删

{

       //1.是否解引用 2 .看具体场景

       assert(pphead); // 链表为空，pphead也永远不为空，因为他是头指针plist的地址

       assert(*pphead); // 链表为空，不能头删。（当然你还可以用温柔的检查）

       SLTNode* del = *pphead;

       *pphead = (*pphead)->next;

       free(del);    //不能free     *pphead ， 因为他的空间已经改变了

       // 一个节点

       // 多个节点

       //if ((*pphead)->next == NULL)

       //{

       //     free(*pphead);

       //     *pphead = NULL;

       //}

       //else

       //{

       //     SLTNode* del = *pphead;

       //     //*pphead = del->next;

       //     *pphead = (*pphead)->next;

       //     free(del);

       //}

}

void SLPopBack(SLTNode** pphead)

{

       assert(pphead); // 链表为空，pphead也不为空，因为他是      头指针plist    的地址

       assert(*pphead); // 链表为空，不能头删。（当然你还可以用温柔的检查）

       // 没有节点(空链表)

       // 暴力检查

       //assert(*pphead);

       // 温柔的检查

       /*if (*pphead == NULL)

       {

              return;

       }*/

       // 一个节点

       // 多个节点

       if ((*pphead)->next == NULL)

       {

              free(*pphead);

              *pphead = NULL;

       }

       else

       {

              //SLTNode* prev = NULL;

              //SLTNode* tail = *pphead;

               找尾

              //while (tail->next)

              //{

              //     prev = tail;

              //     tail = tail->next;

              //}

              //free(tail);

              //prev->next = NULL;

              SLTNode* tail = *pphead;

              // 找尾

              while (tail->next->next)     //为了找到前一个节点next置空，需要一个让tail为倒数第二个节点

              {

                      tail = tail->next;

              }

              free(tail->next);

              tail->next = NULL;

       }

}

SLTNode* STFind(SLTNode* phead, SLTDataType x)    //查找会返回当前节点的指针，所以如果查找不为空，可以直接进行修改

{

       //assert(phead);

       SLTNode* cur = phead; //遍历时一般会利用一个新的指针，而不是头指针

       while (cur)           //直到为空指针        //不能是cur->next     ，否则最后一个节点无法访问

       {

              if (cur->data == x)          //当前cur的date

              {

                      return cur;           //返回节点的指针              （要弄清楚修改节点和修改节点的指针的区别！） 

              }

              cur = cur->next;      //通过next 连接整个链表

       }

       return NULL;

}

// 在pos之前插入：prev指向的新节点是新插入的节点

void SLInsert(SLTNode** pphead, SLTNode* pos, SLTDataType x)     //pos是某个节点的指针 //前插需要pphead，后插不需要（前插需要判断pos是不是首元素！）

{

       assert(pphead);

       assert(pos);  //在pos之前插入需要断言！（也可以不断言，多写一个尾插）

       //assert(*pphead);           //*pphead为空，那么pos也为空（*pphead为空，则说明节点不存在，那么pos这个位置，一定为空）

       if (*pphead == pos)   //如果是第一个元素的话，那么plist（即*pphead） == pos

       {

              SLPushFront(pphead, x);      //那么就需要头插

       }

       else

       {

              SLTNode* prev = *pphead;

              while (prev->next != pos)    //找前一个节点，如果后一个是pos，那么就找到了（== pos 时停止）

              {

                      prev = prev->next;

              }

              SLTNode* newnode = BuyLTNode(x);

              prev->next = newnode; //newnode是堆区新开辟的空间

              newnode->next = pos;  //newnode—>next也是在堆区开辟的空间 //指向的是pos，不是pre—>next！

       }

}

// 在pos之后插入

void SLInsertAfter(SLTNode* pos, SLTDataType x)           //find之后，会返回当前的指针，传给pos使用

{

       assert(pos);

       SLTNode* newnode = BuyLTNode(x);

       newnode->next = pos->next;   //可以为NULL；

       pos->next = newnode;

}

// 删除pos位置的值

void SLErase(SLTNode** pphead, SLTNode* pos)              //前删需要pphead，后删不需要  需要判断pos是不是首元素！

{

       assert(pphead);

       assert(pos);  //当前元素（前删的元素）不能为空

       if (pos == *pphead)   //只有一个元素，头删

       {

              SLPopFront(pphead);

       }

       else   //多个元素

       {

              SLTNode* prev = *pphead;

              while (prev->next != pos)

              {

                      prev = prev->next;

              }

              prev->next = pos->next;

              free(pos);    //释放pos      //有pos的直接用pos

              //不能置空，因为链表需要链接

       }

}

void SLEraseAfter(SLTNode* pos)            //传找到的一级指针就可以

{

       assert(pos);

       assert(pos->next);    //后删的元素也不能为空

       SLTNode* next = pos->next;          //将next指针，指向 pos->next 这块空间

       //结构体成员next      和     形参next可以共存

       pos->next = next->next;      

       free(next);   //释放空间     无需置空

}

test.c

#include"SList.h"

void TestSList1()
{
    SLTNode* plist = NULL;
    SLPushFront(&plist, 1);
    SLPushFront(&plist, 2);
    SLPushFront(&plist, 3);
    SLPushFront(&plist, 4);

    /*plist = SLPushFront(plist, 1);
    plist = SLPushFront(plist, 2);
    plist = SLPushFront(plist, 3);
    plist = SLPushFront(plist, 4);*/

    SLTPrint(plist);

    SLPushBack(&plist, 5);
    SLTPrint(plist);
}

void TestSList2()
{
    SLTNode* plist = NULL;
    SLPushBack(&plist, 1);
    SLPushBack(&plist, 2);
    SLPushBack(&plist, 3);
    SLPushBack(&plist, 4);
    SLTPrint(plist);

    SLPopBack(&plist);
    SLTPrint(plist);
    SLPopBack(&plist);
    SLTPrint(plist);
    SLPopBack(&plist);
    SLTPrint(plist);
    SLPopBack(&plist);
    SLTPrint(plist);

    //SLPopBack(&plist);
}

void TestSList3()
{
    SLTNode* plist = NULL;
    SLPushBack(&plist, 1);
    SLPushBack(&plist, 2);
    SLPushBack(&plist, 3);
    SLPushBack(&plist, 4);
    SLTPrint(plist);

    SLTNode* pos = STFind(plist, 3);
    if(pos)
        pos->data = 30;
    SLTPrint(plist);
}


void TestSList4()
{
    SLTNode* plist = NULL;
    SLPushBack(&plist, 1);
    SLPushBack(&plist, 2);
    SLPushBack(&plist, 3);
    SLPushBack(&plist, 4);
    SLTPrint(plist);

    SLTNode* pos = STFind(plist, 3);
    if (pos)
    {
        SLInsert(&plist, pos, 30);    //插入时先查找，找到返回的地址
    }
    SLTPrint(plist);

    pos = STFind(plist, 2);
    if (pos)
    {
        SLInsertAfter(pos, 20);    //先查找，找到返回的地址
    }
    SLTPrint(plist);

    pos = STFind(plist, 2);    //先查找，找到返回的地址
    if (pos)
    {
        SLErase(&plist, pos);
    }
    SLTPrint(plist);
}

值得一提的是

1.形参的修改不会影响实参，想要修改指针的指向，需要利用二级指针传参去修改一级指针（必须有一层解引用材才可以！！！）

2.分析链表头插尾插的时候，画图，分析date 和 naxt 的指向

3.要对链表进行数据操作时，一定是通过next指针

4.指针的地址可以作为真假的逻辑判断条件    如while（list->next != NULL)    可以直接写成（list->next）
5.对于传指针而言：增删查改，只有查、打印不需要传二级指针，传的是一级指针；其余的操作（增删改）都需要传二级指针       
对于断言而言： //1.是否解引用 2 .看具体场景（一般删有事，插没事（空也可以插入））
1.空指针不能解引用，牵扯到解引用时会断言；
2.一定不会为空的指针要去断言。如果要解引用，一定要对当前指针去断言！    不可以胡乱断言！ 
不好分析的时候，可以画图： pphead——>plist——>节点    比如头删 ：plist不可以为空，否则没东西删除，所以需要断言assert（*pphead）；pphead不能为空，因为pphead时plist的地址，一定不为空。
pphead一般都要断言！ 
6.把next当成一个独立的节点去分析（是pos的下一个节点）。指针next只是一个存地址的变量，指针赋值赋给别人的时候，要明白是让别的指针指向该指针的空间！！！    当指针理解时，next和date连接在一起，当空间理解的时候，要独立出来。
7.当插入的时候，进行指针指向时，一定要分析出，被指向的next有没有被修改
8.插与删，一定要判断pos是不是*pphead。
有些删除需要指针置空，有些则不需要！进行删除操作的时候要注意！

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.mzph.cn/news/737300.shtml

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

《软件项目管理：从规划到实施的全面指南》

《软件项目管理：从规划到实施的全面指南》

软件项目管理是当今信息技术领域中至关重要的一环。在一个数字化、信息化的时代&#xff0c;几乎所有行业都依赖于软件来支撑其业务流程和运营。然而&#xff0c;软件开发过程往往是复杂的&#xff0c;充满了挑战和风险。为了确保软件项目能够按时交付、在预算范围内完成&#…
阅读更多...
『大模型笔记』大模型中的Scaling Law(规模法则)

『大模型笔记』大模型中的Scaling Law(规模法则)

大模型中的Scaling Law(规模法则) 文章目录 一. 核心结论二. 大模型中的Scaling Law三. 参考文献Scaling Laws简单介绍就是：随着模型参数量大小、数据集大小和用于训练的浮点数计算量的增加，模型的性能会提高。并且为了获得最佳性能，所有三个因素必须同时放大。当不受其他两…
阅读更多...
每日OJ题_牛客OR57 手套

每日OJ题_牛客OR57 手套

目录 牛客OR57 手套 解析代码 牛客OR57 手套 手套_牛客题霸_牛客网 class Gloves { public:int findMinimum(int n, vector<int> left, vector<int> right) {} }; 解析代码 class Gloves { public:int findMinimum(int n, vector<int> left, vector<i…
阅读更多...
C++析构函数详解

C++析构函数详解

目录 如果对你有帮助的话&#xff0c;点个赞吧&#xff01; 析构函数概念&#xff1a; 析构函数定义&#xff1a;类名前面加上~ 注意事项&#xff1a; 关于对象的销毁顺序&#xff1a; 析构函数概念&#xff1a; 在对象销毁的时候会自动调用析构函数&#xff0c;对相关资源…
阅读更多...
Tomcat容器经常重启问题排查

Tomcat容器经常重启问题排查

报错代码: INFO [Catalina-utility-2] org.apache.catalina.core.StandardContext.reload Reloading Context with name [] has started1.查看内存占用情况:top 可以发现java线程正常情况下占用高达24%的内存资源 2.继续排查:top -Hp 29580 可以发现主要有子线程Catalina-ut…
阅读更多...
探索ChatGPT在软件架构师工作中的应用

探索ChatGPT在软件架构师工作中的应用

随着人工智能技术的不断发展&#xff0c;自然语言处理模型如OpenAI的ChatGPT已经成为了解决各种实际问题的强大工具之一。在软件架构师这个领域&#xff0c;ChatGPT也有着广泛的应用。本文将探讨软件架构师如何有效地利用ChatGPT来解决问题和提高工作效率。 ChatGPT简介 Chat…
阅读更多...
Java高级编程—注解

Java高级编程—注解

文章目录 1.注解的概述2.常见的Annotation示例2.1 生成文档相关的注解2.2 在编译时进行格式检查的注解2.3 跟踪代码依赖性&#xff0c;实现替代配置文件功能的注解 3.自定义Annotation4.JDK中的元注解4.1 Retention4.2 Target4.3 Documented & Inherited 5. JDK8中注解的新…
阅读更多...
vue 中的性能优化

vue 中的性能优化

1&#xff09;编码优化 尽量减少data中的数据&#xff0c;data中的数据都会增加getter和setter&#xff0c;会收集对应的watcherv-if和v-for不能连用如果需要使用v-for给每项元素绑定事件时使用事件代理SPA 页面采用keep-alive缓存组件在更多的情况下&#xff0c;使用v-if替代…
阅读更多...
服务器出现故障如何恢复数据？

服务器出现故障如何恢复数据？

服务器数据恢复案例之服务器raid6中3块硬盘离线导致阵列崩溃的数据恢复案例 服务器故障&#xff1a; 服务器中有一组由6块盘组建的 RAID6&#xff0c;这台网站服务器上运行MYSQL数据库和存放其它类型的文件。该组raid中有两块磁盘离线&#xff0c;管理员没有及时更换磁盘&#…
阅读更多...
【Numpy】练习题100道（1-25题）

【Numpy】练习题100道（1-25题）

#学习笔记# 在学习神经网络的过程中发现对numpy的操作不是非常熟悉&#xff0c;遂找到了Numpy 100题。 Git-hub链接 目录 1 题目列表&#xff1a; 2 题解&#xff1a; 1 题目列表&#xff1a; 导入numpy包&#xff0c;并将其命名为np&#xff08;★☆☆&#xff09; 打印…
阅读更多...
【Flink SQL】Flink SQL 基础概念：数据类型

【Flink SQL】Flink SQL 基础概念：数据类型

Flink SQL 基础概念&#xff1a;数据类型 1.原子数据类型1.1 字符串类型1.2 二进制字符串类型1.3 精确数值类型1.4 有损精度数值类型1.5 布尔类型&#xff1a;BOOLEAN1.6 日期、时间类型 2.复合数据类型3.用户自定义数据类型 Flink SQL 内置了很多常见的数据类型&#xff0c;并…
阅读更多...
常用的推荐算法

常用的推荐算法

推荐系统在帮助用户发现可能感兴趣的产品、服务或信息方面发挥着重要作用。下面是一些常用的推荐算法&#xff1a; 1. 协同过滤 用户基于协同过滤&#xff08;User-Based Collaborative Filtering&#xff09; 基于用户之间的相似性为用户推荐物品。算法会找出与目标用户兴趣…
阅读更多...
Spring boot创建第一个项目

Spring boot创建第一个项目

作者简介&#xff1a; zoro-1&#xff0c;目前大二&#xff0c;正在学习Java&#xff0c;数据结构&#xff0c;spring等 作者主页&#xff1a; zoro-1的主页 欢迎大家点赞 &#x1f44d; 收藏 ⭐ 加关注哦&#xff01;&#x1f496;&#x1f496; Spring boot创建第一个项目 sp…
阅读更多...
基于单片机的视觉导航小车设计

基于单片机的视觉导航小车设计

目 录 摘 要 I Abstract II 引 言 1 1 总体方案设计 3 1.1 方案论证 3 1.2 项目总体设计 3 2 项目硬件设计 4 2.1 主控模块设计 4 2.1.1单片机选型 4 2.1.2 STM32F103RCT6芯片 4 2.2单片机最小系统电路 5 2.3电机驱动模块设计 7 2.4红外模块设计 8 2.5红外遥控模块设计 9 2.6超…
阅读更多...
设计模式深度解析：工厂方法模式与抽象工厂模式的深度对比

设计模式深度解析：工厂方法模式与抽象工厂模式的深度对比

​&#x1f308; 个人主页&#xff1a;danci_ &#x1f525; 系列专栏&#xff1a;《设计模式》 &#x1f4aa;&#x1f3fb; 制定明确可量化的目标&#xff0c;坚持默默的做事。 探索设计模式的魅力&#xff1a;工厂方法模式文章浏览阅读17k次&#xff0c;点赞105次&#xff0…
阅读更多...
Axure 单键快捷键 加快绘图速度 提高工作效率

Axure 单键快捷键 加快绘图速度 提高工作效率

画图类 R&#xff1a;绘制矩形 先点击空白页面&#xff0c;输入R即可绘制 L&#xff1a;绘制直线 先点击空白页面&#xff0c;输入L即可绘制&#xff0c;绘制的时候按住shift直线 O&#xff1a;绘制圆 先点击空白页面&#xff0c;输入O即可绘制&#xff0c;绘制的时候按…
阅读更多...
skynet cluster集群笔记

skynet cluster集群笔记

skynet cluster集群笔记 前言cluster相关方法说明集群设计方案&#xff1a;集群中常遇到的问题&#xff1a;注意事项&#xff1a; 前言 skynet 是一个基于事件驱动的分布式游戏服务器框架&#xff0c;支持构建高性能、高并发的网络程序。在 skynet中&#xff0c;集群是指将多个…
阅读更多...
最新：Selenium操作已经打开的Chrome(免登录)

最新：Selenium操作已经打开的Chrome(免登录)

最近重新尝试了一下&#xff0c;之前写的博客内容。重新捋了一下思路。 目的就是&#xff0c;selenium在需要登录的网站面前&#xff0c;可能就显得有些乏力&#xff0c;因此是不是有一种东西&#xff0c;可以操作它打开我们之前打开过的网站&#xff0c;这样就不用登录了。 …
阅读更多...
FPGA TestBench编写学习

FPGA TestBench编写学习

1 timescale 1.1 简介 timescale指令用于指定编译器在处理仿真时的时间单位和时间精度。这个指令通常在模块的顶层声明中使用&#xff0c;它告诉编译器和仿真器如何解释代码中的时间值。 timescale指令的语法如下&#xff1a; timescale <time_unit> <time_precis…
阅读更多...
并发通信（网络进程线程）

并发通信（网络进程线程）

如果为每个客户端创建一个进程&#xff08;或线程&#xff09;&#xff0c;因为linux系统文件标识符最多1024位&#xff0c;是有限的。 所以使用IO复用技术&#xff0c;提高并发程度。 阻塞与非阻塞 阻塞式复用 非阻塞复用 信号驱动IO 在属主进程&#xff08;线程中声明&…
阅读更多...
最新文章

Copyright @ 2022~2023