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

已于 2024-03-11 21:43:37 修改
阅读量1.3k 收藏 6
点赞数 46
分类专栏： 数据结构的实现 文章标签： c语言 算法 数据结构 链表
于 2024-03-11 21:41:13 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2302_80190394/article/details/136635677
版权

首先需要借助三个文件        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。
有些删除需要指针置空，有些则不需要！进行删除操作的时候要注意！
Ris Hen
关注
  • 46
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构链表：单链表的代码实现
03-20
本文通过数据结构教程的方法利用C++语言写了单链表的各项功能 功能包括 1.链表的初始化 2.链表的查找和判断是否为空表 3.插入 4.取值 5.插入（尾插法） 6.链表的输出 7.//删除指定元素 8.//链表的释放 其中有着详细...
循环链表——循环单链表与循环双链表——相关C语言代码实现
qq_45965736的博客
09-16 482
本文是对数据结构中的循环单链表和循环双链表的学习。包括与普通链表的对比，初始化的定义代码实现，如何判空，表尾结点判断，以及循环双链表的插入，删除操作等原理，C语言实现。
数据结构——单链表（C语言实现）
weixin_57154303的博客
08-23 3707
单链表的基本操作有 初始化，头插，尾插，按位置插，头删，尾删，按位置删，查找，按值删，获取有效值个数，判空，清空，销毁，打印 - 单链表是一种链式存取的数据结构，链表中的数据是以结点来表示的，每个结点的构成：==元素(数据元素的映象)== + ==指针(指示后继元素存储位置)==，元素就是存储数据的存储单元，指针就是连接每个结点的地址数据。以“结点的序列”表示的线性表称作线性链表（单链表），单链表是链式存取的结构。
数据结构——单链表详解（C语言实现）
sinzz的博客
03-08 1236
首先，我们需要知道，单链表内所需要的数据有两种，一种是数据，还有就是下一个节点的指针。所以我们需要定义一个结构体。//重命名单链表的数据 //便于不同数据类型的切换 typedef struct SLTNode {//SLTNode* next//错误 //改写法C语言是不支持的 //struct SLTNode//错误 } SLTNode;
数据结构之链表——单链表的逆置
weixin_64495476的博客
07-06 582
【代码】数据结构之链表——单链表的逆置。
Python——数据结构——链表——单链表
qq_41188247的博客
12-13 1307
Python——数据结构——链表——单链表
泛型链表——C语言实现
01-24
使用C语言实现的“泛型链表”，该链表为循环双链表，它的设计参考了C++的STL容器库中的容器list及泛型算法的接口，并使用迭代器来遍历链表。使用时只需要include头文件即可，隐藏了List类型的具体实现。用户并不需要...
链表-使用C语言单链表实现的贪吃蛇小游戏.zip
03-13
链表 链表_使用C语言单链表实现的贪吃蛇小游戏
链表的C语言实现之单链表的实现
08-03
链表又分为单链表、双向链表和循环链表等。我们先讲讲单链表。所谓单链表，是指数据接点是单向排列的。
链表-使用C语言实现带头结点的单链表.zip
03-13
链表 链表_使用C语言实现带头结点的单链表
比大小（打擂台）（C语言）
m0_67184754的博客
05-14 215
【代码】比大小（打擂台）（C语言）
c语言：递归与迭代
qq_58761784的博客
05-14 1090
它却没有得出结果，这是为什么呢，因为，函数在内部多次调用了自己，产生了大量的重复计算，导致计算量巨大，代码执行效率非常低，让计算机也无法快速得出结果，这个例子告诉我们，递归是有使用条件的 ，如果要设计一个需要重复计算的程序，不能无脑使用递归，而是首先要思考递归能不能用，是否能让代码简洁的同时，更加高效，那么此类例子我们如何解决呢？可以看到，很快就得到了结果，但是答案是错误的，因为要求的数太大，一个字节无法表示，但是我们可以很直观的看见两者的差别，在这这样一个例子中，使用迭代会优于使用递归。
手撕C语言题典——链表的中间节点
Antigonos的博客
05-14 402
链表的中间节点同样也是力扣上一道简单题，适合刚学过单链表的我们更好的理解链表相关知识~
[每日一题]169：找出最大的可达成数字
AngelDg的博客
05-21 217
题目要求得一个最大的整数 x，使其在不超过 t 次操作内变成与 num 相等的数字。每次操作可以选择将 x 增加或减少 1，同时可以选择将 num 增加或减少 1。返回所有可达成数字中的最大值。可以证明至少存在一个可达成数字。给你两个整数 num 和 t。
质数和约数
最新发布
2302_77099705的博客
05-21 699
最大公约数（Greatest Common Divisor）指两个或多个整数共有约数中最大的一个。也称最大公因数、最大公因子，a， b的最大公约数记为（a，b），同样的，a，b，c的最大 公约数记为（a，b，c），多个 整数的最大公约数也有同样的记号。求最大公约数有多种 方法，常见的有 质因数分解法、 短除法、 辗转相除法、 更相减损法。
C动态内存管理
aqiangdeba的博客
05-17 348
malloccallocreallocfree原则：谁申请，谁释放，防止内存泄漏在C语言中，当你传递一个指针给一个函数时，你实际上是传递了指针的副本，而不是指针本身。这意味着，虽然你在函数内部可以通过这个指针修改指向的内存，但对于指针本身的修改（例如将它指向一个新的内存地址），这种修改不会影响到函数外部指针的值。
算法刷题笔记 逆序对的数量（C++实现）
hanmo22357的博客
05-18 310
AcWing上的算法基础课题目 逆序对的数量 刷题笔记记录
【算法刷题day60】Leetcode：84. 柱状图中最大的矩形
qq_45022758的博客
05-21 210
暂无84. 柱状图中最大的矩形代码随想录解析。
P1135 奇怪的电梯
loongnoy的博客
05-17 277
大楼的每一层楼都可以停电梯，而且第 𝑖i 层楼（1≤𝑖≤𝑁1≤i≤N）上有一个数字 𝐾𝑖Ki​（0≤𝐾𝑖≤𝑁0≤Ki​≤N）。例如： 3,3,1,2,53,3,1,2,5 代表了 𝐾𝑖Ki​（𝐾1=3K1​=3，𝐾2=3K2​=3，……），从 11 楼开始。第一行为三个用空格隔开的正整数，表示 𝑁,𝐴,𝐵N,A,B（1≤𝑁≤2001≤N≤200，1≤𝐴,𝐵≤𝑁1≤A,B≤N）。对于 100%100% 的数据，1≤𝑁≤2001≤N≤200，1≤𝐴,𝐵≤𝑁1≤A,B≤N，0≤𝐾𝑖≤𝑁0≤Ki​≤N。
链表c语言代码 反转函数,单链表反转C语言实现
06-10
好的，下面是单链表反转的C语言实现代码： ```c #include #include struct ListNode { int val; struct ListNode *next; }; struct ListNode* reverseList(struct ListNode* head) { struct ListNode* prev = ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值