数据结构与算法实战：链表

最新推荐文章于 2024-05-01 23:46:50 发布
最新推荐文章于 2024-05-01 23:46:50 发布
阅读量324 收藏 3
点赞数 6
分类专栏： 数据结构 文章标签： 链表 数据结构 算法 c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_37410388/article/details/120674583
版权

目录

链表的基本理论

链表属于线性表的元一种，与顺序表不同的是，虽然链表在逻辑上具有连续性，但其的物理存储却是不一定连续的，链表的每一个元素又称之为一个结点，每一个结点都是我们随机在内存中开辟的空间，正是由于这一特点，所以链表的长度是不固定的，为了构成链式的逻辑结构，即一个结点链接一个的结点的的逻辑结构，我们每个结点除了要储存元素的信息外，还要储存下一个结点的地址(指针)，以便我们可以链式访问每一个元素。

在这里插入图片描述

为了同时存储元素的信息和下一个结点的地址(指针)，所以我们用结构体来定义链表的结点

struct Node
{
    int data;//存储元素的信息
    struct Node* next;//所存储的下一个结点的类型为结构体，所以我们用结构体指针来存储
};

A结点指向B结点的具体含义：A结点的指针域存储了B结点的内存地址(指针)

链表的基本操作

1.插入操作：在第K个位置插入元素

2.删除操作：删除第K个位置的元素

3.查找操作：查找第K个元素或查找值为X的元素

链表的实现方式有多种，这里我们选择实现带头指针的链表，头指针的类型为结构体指针，仅用来存储所指向的第一个元素的地址，不存储任何元素信息

struct Node* head; //头指针的创建

链表的初始化

init(&head);//将我们要初始化的链表的头指针作为参数传过去

由于头指针的初始化一定会成功，我们不需要他返回成功与否的信息,故函数的返回值类型为void

void init(struct Node** phead)
{
    *phead = NULL;//将头结点初始化
}

因为我们的链表还没有插入元素，所以我们在将头指针在初始化时要置为空，这其实是对我们传过来的指针的一种修改，对于传过来的变量的地址(指针)，我们可以直接操作该变量的指针对该变量进行修改，同样的道理，若我们想要直接对指针变量进行修改，我们需要将指针变量的地址(指针)传过来，所以我们要用二级指针来承接。

链表结点的创建

在我们操作链表时，每次插入都需要先创建一个结点，故我们把他封装成一个函数，便于提高代码的可读性，该函数的返回类型是我们所创建结点的地址(指针)

struct Node* createNode(int x)//x表示我们要插入结点元素的值
{
    struct Node* t;//创建该结点类型的指针
    t = (struct Node*)malloc(sizeof(struct Node));
    t->next = NULL;//一个好习惯是所有的指针域都不能保持为未赋值状态
    t->data = x;
    return t;
}

求链表的长度

该函数的调用

getLength(head)

我们在求长度时进行的是只读的操作，不会改变链表，所以仅传递该链表的头指针而没有传递该头指针的地址

int getLength(struct Node* head)//该返回值类型用于返回链表的长度
{
    int len = 0;//该变量用于记录链表的长度
    while (head != NULL)//若当前指针指向的结点不为空，len++
    {
        len++;
        head = head->next;//改变的是局部变量(head的形参，是真正head的一份临时拷贝)，没有改真正的head值
    }
    return len;//返回链表的长度
}

查找链表的第K个元素

我们在第K个位置插入元素时，首先要判断其插入的合法性，当他的第K-1个位置上有元素时，该操作是一定合法的，所以我们调用该函数查找第K-1个元素

查找函数的调用

findKth(*phead,k-1)//与求长度函数一样，我们在传参时仅需要传递头指针

接下来我们分析一下这个函数

struct Node* findKth(struct Node* head,int k)
{
    int count=1;//用于控制查找元素时循环的停止
    struct Node* p=head;
    while(p!=NULL&&count<k)
    {
        p=p->next;
        count++;
    }
    return p;
}

当链表为空时，我们的查找一定是失败的，所以while循环一定会结束，直接返回空指针NULL，当链表中只有一个元素时，我们的头指针是指向第一个元素的，我们查找第一个元素时while循环也会不满足count<1这一条件而结束，从而返回我们的头指针，也就是我们第一个元素的地址，我们经常会遇到写循坏条件时取不取等的问题，一个很好的方法就是找一些特殊情况和我们手动进行一些小范围的模拟循坏来判断我们的循坏条件到底怎么写。

链表的插入

在这里插入图片描述

因为我们的插入操作是有可能改变头指针的，所以我们要传入我们链表头指针的地址，以下是插入函数的调用

insert(&head, 1, 11)//在链表的第一个位置上插入元素为11的结点

关于插入函数的合法性其实也是可以用getLength()函数来判断的：if(k<0||k>getLength(head)) ,但是我们的插入操作的时间复杂度已经是O(N)了，如果在判断合法性的时候调用同样也为O(N)的getLength()函数，这就使得插入函数的效率变得很低了，而我们直接使用时间复杂度为O(N)的findKth()函数，函数找到第K-1个元素后会返回该元素的地址，我们就可以直接利用该地址进行插入操作，我们的时间复杂度也就仅为O(N)了 ，同时我们的插入操作可能会失败，所以我们的函数返回值为int型，返回值为1表示操作成功，返回值为0表示插入失败。

int insert(struct Node** phead, int k, int x)
{
    if (k < 1) {    //不合法，操作失败
        return 0;
    }
    else if (k == 1)
    {
        struct Node* t;
        t=createNode(x);
        t->next = *phead;//如若不这样就会把原来的结点都丢失
        *phead = t;
        return 1;//操作成功，返回1
    }
    else 
   {
        struct Node* p;
        p = findKth(*phead,k-1);
        //例如:在只有3个元素的链表中，在第5个位置插入元素也是不合法的，
        //调用查找函数时返回值是NULL，所以插入会失败
        if (p)  //可以插入的话，p是不为空的
        {
            struct Node* t;
            t = createNode(x);
            t->next = p->next;
            p->next = t;
            return 1;//操作成功，返回1
        }
        else
        {
            return 0;
        }
    }
    
}

我们对该函数进行一下分析：

在第一个位置上插入元素是一种特殊情况，是需要单独考虑的，因为第一个元素之前是没有元素的，一个最重要的操作就是先创建一个结点，使用该结点承接插入操作之前头指针指向的地址，防止原来的结点丢失，然后将我们创建结点的地址赋给头指针，让这段“链条”重新接起来，同理在往其他位置插入元素时，也是需要先用我们创建好的结点去保存我们前一个结点的next指针的(t->next = p->next)，这样可以防止我们丢失原来的结点，因为我们每个结点的链接都是通过地址来链接的，然后将我们前一个指针的next值赋值为我们创建结点的地址(p->next = t)，使我们整个的链表连接起来。

链表的删除

在这里插入图片描述

函数的调用：在进行函数的删除操作时，我们先定义一个变量x，在调用删除函数时将其指针传过去，目的是为了让其记录我们所删除元素的值，至于为什么要传该参数的指针，我们在上一篇顺序表的实现中就讲过，这里就不再赘述，同样的道理，我们的删除操作是有可能要修改头指针的，所以我们在传参时要将头指针的地址传过去

int x;//用x来获取删除点的值
int k=removeNode(&head, 5, &x);//删除单链表中第5个位置上的元素

和插入操作相同，删除操作同样要进行合法性的判断，并且讨论删除第一个位置元素的这种特殊情况，同样删除操作也可能会失败，所以我们函数的返回类型我们定义为int型，操作成功返回1，失败返回0。具体的一些细节我们写在了注释中

int removeNode(struct Node** phead, int k, int* px)
{
    if (k < 1) //不合法，返回0
    {
        return 0;
    }
    else if(k==1)//删除第一个点的讨论
    {
        if (*phead != NULL)//单链表不为空
        {
            //先将我们要删除的结点的值赋给我们之前传参传过来的变量
            *px = (*phead)->data;
            //(*phead)->next是第一个结点的后一个结点的地址(指针)
            *phead = (*phead)->next;
            return 1;
        }
        else
            return 0;//空链表不存在删除第一个节点
    }
    else
    {
        struct Node* p;
        p = findKth(*phead, k - 1);
        //删除第K个，先找K-1，但找到K-1之后，若K-1为最后一个，第K个也不能删除
        if (p == NULL||p->next==NULL)
        {
            return 0;
        }
        else
        {
            struct Node* t;
            //p为找到的第k-1位置的结点地址，t为第K位置结点的地址
            t = p->next;
            //删除第K位置的结点就是将第K-1个结点的指针指向第K+1个结点
            p->next = t->next;
            *px = t->data;//将我们要删除的结点的值赋给我们之前传参传过来的变量
            //将被我们删除的第K个结点的申请的内存空间释放掉,这也是我们定义变量t的意义所在
            free(t);
            return 1;
        }
    }
}

链表的输出

我们可以写一个打印函数来感受我们链表操作的具体效果

void printLList(struct Node* head)
{
    while (head != NULL)
    {
        printf("%d, ", head->data);
        head = head->next;
    }
}

效果测试

以下是完整测试代码及效果

#include<stdio.h>
#include<stdlib.h>

struct Node
{
    int data;
    struct Node* next;
};

void init(struct Node** phead)
{
    *phead = NULL;//将头结点初始化
}

struct Node* createNode(int x)//x表示我们要插入结点元素的值
{
    struct Node* t;//创建该结点类型的指针
    t = (struct Node*)malloc(sizeof(struct Node));
    t->next = NULL;//一个好习惯是所有的指针域都不能保持为未赋值状态
    t->data = x;
    return t;
}

int getLength(struct Node* head)//该返回值类型用于返回链表的长度
{
    int len = 0;//该变量用于记录链表的长度
    while (head != NULL)//若当前指针指向的结点不为空，len++
    {
        len++;
        head = head->next;//改变的是局部变量(head的形参，是真正head的一份临时拷贝)，没有改真正的head值
    }
    return len;//返回链表的长度
}

struct Node* findKth(struct Node* head,int k)
{
    int count=1;//用于控制查找元素时循环的停止
    struct Node* p=head;
    while(p!=NULL&&count<k)
    {
        p=p->next;
        count++;
    }
    return p;
}

int insert(struct Node** phead, int k, int x)
{
    if (k < 1) {    //不合法，操作失败
        return 0;
    }
    else if (k == 1)
    {
        struct Node* t;
        t=createNode(x);
        t->next = *phead;//如若不这样就会把原来的结点都丢失
        *phead = t;
        return 1;//操作成功，返回1
    }
    else 
   {
        struct Node* p;
        p = findKth(*phead,k-1);
        //例如:在只有3个元素的链表中，在第5个位置插入元素也是不合法的，
        //调用查找函数时返回值是NULL，所以插入会失败
        if (p)  //可以插入的话，p是不为空的
        {
            struct Node* t;
            t = createNode(x);
            t->next = p->next;
            p->next = t;
            return 1;//操作成功，返回1
        }
        else
        {
            return 0;
        }
    }
    
}

int removeNode(struct Node** phead, int k, int* px)
{
    if (k < 1) //不合法，返回0
    {
        return 0;
    }
    else if(k==1)//删除第一个点的讨论
    {
        if (*phead != NULL)//单链表不为空
        {
            //先将我们要删除的结点的值赋给我们之前传参传过来的变量
            *px = (*phead)->data;
            //(*phead)->next是第一个结点的后一个结点的地址(指针)
            *phead = (*phead)->next;
            return 1;
        }
        else
            return 0;//空链表不存在删除第一个节点
    }
    else
    {
        struct Node* p;
        p = findKth(*phead, k - 1);
        //删除第K个，先找K-1，但找到K-1之后，若K-1为最后一个，第K个也不能删除
        if (p == NULL||p->next==NULL)
        {
            return 0;
        }
        else
        {
            struct Node* t;
            //p为找到的第k-1位置的结点地址，t为第K位置结点的地址
            t = p->next;
            //删除第K位置的结点就是将第K-1个结点的指针指向第K+1个结点
            p->next = t->next;
            *px = t->data;//将我们要删除的结点的值赋给我们之前传参传过来的变量
            //将被我们删除的第K个结点的申请的内存空间释放掉,这也是我们定义变量t的意义所在
            free(t);
            return 1;
        }
    }
}

void printLList(struct Node* head)
{
    while (head != NULL)
    {
        printf("%d, ", head->data);
        head = head->next;
    }
}

int main()
{
    struct Node* head;
    init(&head);
    insert(&head, 1, 11);
    insert(&head, 2, 22);
    insert(&head, 3, 33);
    insert(&head, 4, 44);
    insert(&head, 5, 55);
    printf("该链表的长度是:%d\n",getLength(head));
    printLList(head);
    printf("\n");
    int x;//用x来获取删除点的值
    removeNode(&head, 5, &x);
    printf("删除的元素是%d\n", x);
    printLList(head);
    printf("\n");
    removeNode(&head, 1, &x);
    printf("删除的元素是%d\n", x);
    printLList(head);
    printf("\n");
    return 0;
}

在这里插入图片描述

链表的主要操作我们都已经实现完毕，其他的一些操作都可以基于我们现有的操作进行实现，且实现方法很简单，这里就不在赘述，鉴于笔者水平有限，本文可能存在一些错误，笔者也会虚心学习，请大家多多指正！

Two_Fly
关注
  • 6
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
约瑟夫生者死者游戏-Python数据结构与算法实战项目完整源码与界面资源
07-01
约瑟夫生者死者问题是数据结构与算法中的经典问题，本项目基于单向循环链表这一数据结构实现，并使用 tkinter技术 实现约瑟夫问题的可视化。项目使用了图形用户界面GUI技术，使用的开发工具为PyCharm 2021.3。实现了约瑟夫游戏的可视化模拟，并对用户输入汉字的情况进行处理，例如用户在输入框中输入总人数为三十三，算法则会将三十三处理为33接收，并进行计算。是学习完Python与数据结构与算法后练手的好项目，也可以用于课程设计的学习参考。算法部分有详细注释，并且该资源已经更新了博客教程，文中对算法进行了图解并对项目结果进行了展示，欢迎下载学习！
结构体定义 typedef struct 用法详解和用法小结
热门推荐
会写Bug的攻城狮
07-31 23万+
typedef是类型定义的意思。typedef struct 是为了使用这个结构体方便。 具体区别在于: 若struct node{ }这样来定义结构体的话。在定义 node 的结构体变量时，需要这样写:struct node n; 若用typedef，可以这样写：typedef struct node{}NODE; 。在申请变量时就可以这样写：NODE n;其实就相当于 NODE 是nod...
【线性表】单链表及其基本运算和应用
weixin_45765128的博客
03-11 1014
单链表的c语言定义 typedef struct Node { ElemType data;/*数据域*/ struct Node *next;/*指针域*/ } Node,*LinkLIst;/*给node起两个别名，这两个别名等效*/ LinkLIst L;/*L为单链表的头指针，也称为单链表L*/ LinkList 与 Node*同为结构指针类斜体样式型，这两种类型是等价的。 通常我...
【c语言】链表（适合初学者）
weixin_74337975的博客
04-07 1991
C语言中的链表是一种常见的数据结构，它由一系列的节点（node）组成，每个节点包含一个数据元素和一个指向下一个节点的指针。链表可以用来表示各种数据结构，例如队列、堆栈、树等。在C语言中，链表的节点通常是通过结构体来定义的。int data;在这个结构体中，data是节点存储的数据元素，next是指向下一个节点的指针。因为next指向的是另一个Node类型的结构体，所以需要使用类型来定义。链表的头指针是指向第一个节点的指针，通常称为head。对于一个空链表，头指针为NULL。链表的尾节点的next。
结构体定义 typedef struct 用法详解和小结
Cerulea_n的博客
06-14 2万+
typedef可以声明新的类型名来代替已有的类型名，但却不能增加新的类型.typedef为C语言的关键字，作用是为一种数据类型定义一个新名字。在编程中使用typedef目的一般有两个，一个是给变量提供一个易记且意义明确的新名字（类型有新别名，方便变量的定义），另一个是简化一些比较复杂的类型声明。在上述的变量定义中，s1、s2、s3都被定义为char *，而s4则定义成了char，不是我们所预期的指针变量，根本原因就在于#define只是简单的字符串替换而typedef则是为一个类型起新名字。
数据结构与算法第二讲-[单向循环链表]
qq_34609583的博客
03-08 397
单向循环链表 单向循环链表： 单链表的最后一个节点的指针指向链表头部，而不是指向NULL，那么就构成了一个单向循环链表，通俗讲就是把尾节点的下一跳指向头结点。 //定义节点 typedef struct Node{ ElemType data ; struct Node *next; }Node; typedef Node *LinkList; • 初始化 循环链表的创建分为两种情况： 1.链表第一次创建: 创建一个新的结点 新结点的next指向自身（*L）->next = (*L.
链栈（结构体实现）
weixin_52119087的博客
10-19 195
【代码】链栈（结构体实现）
顺序表与链表笔记
weixin_40719943的博客
05-22 174
1.单链表定义 typeof struct Node { ElemType data; //定义数据域 struct Node *next;//定义指针域 }LNode,*LinkList; //LNode：节点类型，一般用于创建单个节点时使用； // *LinkList：节点地址，一般用于创建链表时使用，代表整个链表的首地址 2.顺序表定义 方式一： #define MaxSize 50 typedef struct{ ElemType *data; int length...
C语言数据结构_单链表
qq_61726359的博客
04-29 2425
单链表 1.创建一个头结点并初始化 自写的 struct Node { int data; //数据域 struct Node *next; //指针域 }; //创建一个头节点注意初始化 struct Node *createList() { struct Node *headNode = (struct Node *)malloc(sizeof(struct Node)); headNode->data = '\0'; headNode-
数据结构之线性表的链式存储结构 C语言版
bsqetuo的博客
07-05 846
单链表的添加，插入，删除，查找等
Java Data Structures and Algorithms In Action. Java数据结构和算法实战.zip
01-14
算法与数据结构涵盖了以下主要内容： 数据结构（Data Structures）： 逻辑结构：描述数据元素之间的逻辑关系，如线性结构（如数组、链表）、树形结构（如二叉树、堆、B树）、图结构（有向图、无向图等）以及集合和...
cailingling721#data-structures-and-algorithms#数据结构和算法-链表实战-环形链表I
07-25
链表实战题目4 - 链表入环的第一个节点给定一个链表，返回链表开始入环的第一个节点。如果链表无环，则返回 null。为了表示给定链表中的环，我们使用整数 pos
cailingling721#data-structures-and-algorithms#数据结构和算法-链表实战-两两交换链
07-25
# 将第一个节点指向第三个节点# 第二个节点指向第一个节点# 节点first指向第二个节点# 当前节点后移动，记得a.next是节点3，相当于跳了一个节点，往后
【算法小白周赛1E】ET表题解与代码（算法与数据结构刷题计划）
qq_29495615的博客
05-01 432
其实所谓的ET表操作，其实就是对数组的某一长度的前、后缀进行区间减去某个数的操作，此时我们应该想到非常擅长进行区间操作的好东西——差分。StarryCoding - 编程开发新手村，非常适合新手小白的一个网站，推荐给大家~不会有任何影响，所以对它的操作可以忽略，而我们的最终目的——将数组。，现在需要判断能否通过ET表的这两种操作将这个数组的每一个数都变成。的进行一次操作，最后特判一下进行了上述操作后。为了测试ET表的性能，小e找来了一个长度为。的修改就等效于对差分数组的。，以及最少的操作次数。
[数据结构]———交换排序
最新发布
2303_77720864的博客
05-01 310
函数返回的是基准值在排序后的位置，用于在递归调用中分割左右子数组
【数据结构】第二章 线性数据结构.概念性补充
KX_52517的博客
05-01 491
本文是对【数据结构】线性数据结构的补充，若没有疑惑可跳过本文。
【数据结构】链表专题2
m0_74091744的博客
05-01 808
前言本篇博客继续探讨有关链表的专题，这片博客的题，提前打个预防针，有点意思哦，哈哈哈，话不多说，进入正文若有问题 评论区见📝。
【树——数据结构】
爱学习的小刘芒的博客
05-01 496
树——数据结构
【数据结构】位图与布隆过滤器
m0_58963318的博客
05-01 527
详解位图与布隆过滤器
java数据结构与算法csdn
12-18
Java数据结构和算法是计算机科学中的重要概念，它们在计算机程序的设计和优化中起着关键作用。CSND（CSDN）是一个能够提供丰富资源和学习资料的专业IT技术分享社区。在CSND平台上，有很多关于Java数据结构和算法的学习资料和教程，可以帮助初学者和有一定基础的程序员更好地理解和使用这些概念。 Java作为一种流行的编程语言，拥有丰富的数据结构和算法库，例如数组、链表、栈、队列、树、图等，同时也有各种常用的排序和查找算法，如冒泡排序、快速排序、二分查找等。这些数据结构和算法的学习，对于编程能力的提高和程序性能的优化至关重要。 在CSND上，有很多技术大神分享自己的Java数据结构和算法的学习心得和实战经验，同时也有很多经验丰富的程序员提供了大量的实战案例和代码示例，这些都为学习者提供了宝贵的学习资源。 通过在CSND上学习Java数据结构和算法，可以帮助我们更好地理解和掌握这些概念，在实际的编程工作中更加得心应手。同时，也可以通过阅读他人的学习笔记和教程，不断提高自己的编程水平和算法思维能力。因此，CSND对于学习Java数据结构和算法的程序员来说是一个非常有价值的学习平台。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值