数据结构-有头单向链表

已于 2024-06-22 15:19:23 修改
阅读量769 收藏 3
点赞数 21
分类专栏： 数据结构 文章标签： 数据结构 链表
于 2024-06-20 20:46:27 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_67273669/article/details/139841426
版权

有头单向链表操作的分文件封装函数实现。

1.创建空表

malloc开辟一块结构体大小的空间作为头结点，通过if判断空间四否开辟成功，然后对头节点进行初始化，刚开始让头节点指向null；

步骤：

（1）malloc开辟一块结构体大小的空间作为头节点

（2）对空间进行初始化，让头节点指向null

// 1.创建一个空的单向链表(有头单向链表)
link_node_t *CreateEpLinkList()
{
    // 开辟空间作为头节点
    link_node_t *head = (link_node_t *)malloc(sizeof(link_node_t));
    if (head == NULL)
    {
        perror("creat malloc error");
        return NULL;
    }
    // 初始化头节点
    head->next = NULL;
    return head;
}

2.向指定位置插入数据

步骤：

（1）将指针移动到参入位置的前一个节点

（2）用指针pnew保存新建的节点地址，pnew = malloc（）；

（3）将数据存入新节点，也就是初始化新节点，

（4）将新节点插入链表，先连后边再连前边

 

插入数据时，需要先判断一下插入位置是否合理，不能越界。

向指定位置插入数据，需要新建节点来存放需要插入的数据，需要malloc开辟一块空间。

指定位置插入数据，只需要把新建的节点跟插入位置前后的两个节点通过指针域连接到一块。

但是电脑不知道需要插入的位置所在的存储空间地址，就需要定义一个结构体类型的指针，让头指针移动到插入位置前边的节点，这样通过该节点的指针域就可以获得插入位置的地址。

在连接时，只能先把新建节点与后面的节点连接，再把新建与前边的节点相连，因为前面节点的指针域里存放的是后面一个节点的地址，如果先连前面，当前面的指针域指向新建节点时，后面节点的地址就找不到了，也就无法连接到后面的节点了。

 

// 2.向单向链表的指定位置插入数据
// p保存链表的头指针 post 插入的位置 data插入的数据
int InsertIntoPostLinkList(link_node_t *p, int post, datatype data)
{
    // 容错判断，如果post越界，插入失败
    if (post < 0 || post > LengthLinkList(p))
    {
        perror(" InsertIntoPostLinkList error  插入失败");
        return -1;
    }
    // 指针移动到插入位置
    for (int i = 0; i < post; i++)
    {
        p = p->next;
    }

    // 新建节点用来保存插入的数据
    link_node_t *pnew = (link_node_t *)malloc(sizeof(link_node_t));
    // 初始化新建节点，存入数据，
    pnew->data = data;
    pnew->next = NULL;
    // 连接 先连后边，再连前边
    pnew->next = p->next;
    p->next = pnew;
    return 0;
}

3.遍历单向链表

遍历有头单向链表，指针先跨过头节点，然后输出每个节点的数据域，当指针与为空时，链表到尾，停止遍历。

// 3.遍历单向链表
void ShowLinkList(link_node_t *p)
{
    while (p->next != NULL)
    {
        p = p->next;
        printf("%d ", p->data);
    }
    printf("\n");
}

4.求单向链表的长度

求单向链表的长度，通过while循环来移动指针，只要指针域不为空，就代表该节点有数据，每循环一次，指针向后移动一位，长度加一。

// 4.求单向链表长度的函数
int LengthLinkList(link_node_t *p)
{
    int length = 0;
    while (p->next != NULL)
    {
        p = p->next;
        length++;
    }

    return length;
}

5.删除指定位置的数据

步骤：

（1）将指针指向被删除的节点的前一个

（2）指针pdel指向要被删除的节点: pdel = p->next 

（3）跨过要删除的节点：p->next = pdel ->next

（4）释放要删除的节点：free(pdel)

删除指定位置数据，也需要先判断一下，如果链表为空，或者山粗的位置越界，那么就无法删除。

删除指定位置数据，只需要把删除的节点跨过去就行了，但是需要先找到删除节点的地址，删除节点的地址存放在前边的节点指针域中，通过指针移动到前边那个节点。

删除节点后，该节点的空间需要释放，如果直接诶把该节点跳过，那么就找不到该节点的地址了，也就无法释放该节点了。所以需要定义一个中间指针，指向删除的节点，用来暂存删除的节点。

等把删除的节点跨过之后，通过中间指针释放删除节点的空间。由于链表中的每个结点都是malloc开辟出来的，故需要一个PDel指针指向结点，将其释放掉。

// 5.删除单向链表中指定位置的数据 post 代表的是删除的位置
int DeletePostLinkList(link_node_t *p, int post)
{
    if (IsEpLinkList(p) || post < 0 || post > LengthLinkList(p))
    {
        printf("无法删除 \n");
        return -1;
    }
    // 移动指针到删除位置的前面
    for (int i = 0; i < post; i++)
    {
        p = p->next;
    }

    // 定义指针指向需要删除的节点，暂存
    link_node_t *pdel = p->next;
    // 跨过需要删除的节点
    p->next = pdel->next;
    // p->next = p->next->next;

    // 释放删除节点的空间
    free(pdel);
    pdel = NULL;

    return 0;
}

 6.修改指定位置的数据

在链表中插入或删除某个结点，不需要移动元素，仅修改指针即可。

步骤：

（1）移动指针到修改位置的节点

（2）对要修改的节点的数据域进行赋值

// 7.修改指定位置的数据 post 被修改的位置 data修改成的数据
int ChangePostLinkList(link_node_t *p, int post, datatype data)
{
    // 容错判断，如果为空，或者越界，那么修改失败
    if (IsEpLinkList(p) || post < 0 || post > LengthLinkList(p))
    {
        printf("无法删除 \n");
        return -1;
    }
    // 移动指针到需要修改的节点
    for (int i = 0; i <= post; i++)
    {
        p = p->next;
    }
    // 修改数据域，重新赋值
    p->data = data;

    return 0;
}

7.查找指定数据出现的位置

步骤：

（1）循环遍历节点，移动指针

（2）每个节点的数据域跟查找的数据进行比较，相等就输出下标，不相等就继续移动指针，同时下标+1

// 8.查找指定数据出现的位置 data被查找的数据 //search 查找
int SearchDataLinkList(link_node_t *p, datatype data)
{
    int n = 0;
    while (p->next != NULL)
    {
        p = p->next;
        if (p->data == data)
        {
            printf("%d 出现在下标为 %d 的位置\n", data, n);
            return 0;
        }
        n++;
    }
    printf("%d 未找到\n", data);
    return 0;
}

 8.删除链表中出现的指定数据

步骤：

（1）跨过头节点，从首元节点开始遍历单链表，相当于用pdel指针遍历无头链表

（2）判断节点中的数据是否为要删除的数据

（3）如果节点中为要删除的数据，那么就跨过被删除节点，然后释放被删除节点，然后pdel继续向后遍历

（4）如果节点不是需要删除的数据，那么p和pdel都向后移动一位

通过遍历链表，循环对比节点的数据，可以删除链表中出现的指定元素。

// 9.删除单向链表中出现的指定数据,data代表将单向链表中出现的所有data数据删除
int DeleteDataLinkList(link_node_t *p, datatype data)
// 写法一
{
    if (IsEpLinkList(p))
    {
        printf("表为空，无法删除 \n");
        return -1;
    }

    // 跨过头节点
    link_node_t *pdel = p->next;
    while (pdel != NULL)
    {
        // 判断节点的值是否为删除的数据
        if (pdel->data == data)
        {
            // 跨过被删除的节点
            p->next = pdel->next;
            // 释放被删除的节点
            free(pdel);
            pdel = NULL;
            // 此时p指针已经指向后一个节点，只需要移动pdel即可
            // 指针后移
            pdel = p->next;
        }
        else
        {
            // 指针后移
            p = p->next;
            pdel = p->next;
        }
    }
    return 0;
}

9.链表逆置

步骤：

（1）断头：将头节点与链表断开，断开之前保存下一个节点的位置，避免断开之后找不到后续链表，定义一个q保存头节点的下一个节点，断开后的链表相当于q为首元节点的一个无头链表。

（2）遍历：遍历无头链表的所有节点，将每一个节点当新节点插入空链表（头插法），头插之前先用temp保存一下q的下一个节点，避免插入q之后找不到后续的链表了。

（3）头插：先将q节点与后边的节点相连，在把头节点与q节点相连。注意必须先连后边再连前边，否则后面的链表节点会丢失。

（4） 循环移动指针：将q指针移动到无头链表的第一个节点，temp指向q的下一个节点，循环进行头插。

// 10.转置链表
// 将头节点与当前链表断开，断开前保存下头节点的下一个节点，保证后面的链表能够找到
// 定义一个q保存头节点的下一个节点，断开后相当于无头节点
// 遍历无头链表的所有节点，将每一个节点当做新节点插入空链表的下一个节点(头插)，
// 头插之前先用temp保存一下q的下一个节点以防插入完之后找不到后续节点
void ReverseLinkList(link_node_t *p)
{
    // 用于暂存头指针后的节点
    link_node_t *q = p->next;
    link_node_t *temp = NULL;
    // 断开头节点与链表
    p->next = NULL;
    while (q != NULL)
    {
        // 让temp暂存q的下一个节点，以防头插q之后找不到原来的链表
        temp = q->next;
        // 将q插入到头节点之后,先连后边，再连前边
        q->next = p->next;
        p->next = q;
        // 移动q到temp，继续遍历链表
        q = temp;
    }
}

 10.清空单向链表

清空单向链表，其实通过循环，把链表中每一个节点都删除，只需要在原先的删除指定位置节点的基础上，加入一个循环，通过循环遍历删除链表中的所有节点。

// 11.清空单向链表
void ClearLinkList(link_node_t *p)
{
    link_node_t *pdel = NULL;
    while (p->next != NULL)
    {
        // pdel暂存要删除的节点
        pdel = p->next;
        // 跨过删除节点
        p->next = pdel->next;
        // 释放删除的节点
        free(pdel);
        pdel = NULL;
    }
    if (IsEpLinkList(p))
    {
        printf("表已清空\n");
    }
}

 11.头文件

封装结构体，进行函数声明

#ifndef _LINKLIST_H_
#define _LINKLIST_H_

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

typedef int datatype; // int 重命名为 datatype

typedef struct node_t
{
    datatype data;       // 数据域
    struct node_t *next; // 指针域,指向自身结构体的指针
} link_node_t, *link_list_t;

// 1.创建一个空的单向链表(有头单向链表)
link_node_t *CreateEpLinkList();

// 2.向单向链表的指定位置插入数据
// p保存链表的头指针 post 插入的位置 data插入的数据
int InsertIntoPostLinkList(link_node_t *p, int post, datatype data);

// 3.遍历单向链表
void ShowLinkList(link_node_t *p);

// 4.求单向链表长度的函数
int LengthLinkList(link_node_t *p);

// 5.删除单向链表中指定位置的数据 post 代表的是删除的位置
int DeletePostLinkList(link_node_t *p, int post);

// 6.判断单向链表是否为空 1代表空 0代表非空
int IsEpLinkList(link_node_t *p);

// 7.修改指定位置的数据 post 被修改的位置 data修改成的数据
int ChangePostLinkList(link_node_t *p, int post, datatype data);

// 8.查找指定数据出现的位置 data被查找的数据 //search 查找
int SearchDataLinkList(link_node_t *p, datatype data);

// 9.删除单向链表中出现的指定数据,data代表将单向链表中出现的所有data数据删除
int DeleteDataLinkList(link_node_t *p, datatype data);

// 10.转置链表
void ReverseLinkList(link_node_t *p);

// 11.清空单向链表
void ClearLinkList(link_node_t *p);

#endif

12.完整函数体

#include "linklist.h"

// 1.创建一个空的单向链表(有头单向链表)
link_node_t *CreateEpLinkList()
{
    // 开辟空间作为头节点
    link_node_t *head = (link_node_t *)malloc(sizeof(link_node_t));
    if (head == NULL)
    {
        perror("creat malloc error");
        return NULL;
    }
    // 初始化头节点
    head->next = NULL;
    return head;
}

// 2.向单向链表的指定位置插入数据
// p保存链表的头指针 post 插入的位置 data插入的数据
int InsertIntoPostLinkList(link_node_t *p, int post, datatype data)
{
    // 容错判断，如果post越界，插入失败
    if (post < 0 || post > LengthLinkList(p))
    {
        perror(" InsertIntoPostLinkList error  插入失败");
        return -1;
    }
    // 指针移动到插入位置
    for (int i = 0; i < post; i++)
    {
        p = p->next;
    }

    // 新建节点用来保存插入的数据
    link_node_t *pnew = (link_node_t *)malloc(sizeof(link_node_t));
    // 初始化新建节点，存入数据，
    pnew->data = data;
    pnew->next = NULL;
    // 连接 先连后边，再连前边
    pnew->next = p->next;
    p->next = pnew;
    return 0;
}

// 3.遍历单向链表
int ShowLinkList(link_node_t *p)
{
    if (IsEpLinkList(p))
    {
        printf("表为空 \n");
        return -1;
    }

    while (p->next != NULL)
    {
        p = p->next;
        printf("%d ", p->data);
    }
    printf("\n");
    return 0;
}

// 4.求单向链表长度的函数
int LengthLinkList(link_node_t *p)
{
    int length = 0;
    while (p->next != NULL)
    {
        p = p->next;
        length++;
    }

    return length;
}

// 5.删除单向链表中指定位置的数据 post 代表的是删除的位置
int DeletePostLinkList(link_node_t *p, int post)
{
    if (IsEpLinkList(p) || post < 0 || post > LengthLinkList(p))
    {
        printf("无法删除 \n");
        return -1;
    }
    // 移动指针到删除位置的前面
    for (int i = 0; i < post; i++)
    {
        p = p->next;
    }

    // 定义指针指向需要删除的节点，暂存
    link_node_t *pdel = p->next;
    // 跨过需要删除的节点
    p->next = pdel->next;
    // p->next = p->next->next;

    // 释放删除节点的空间
    free(pdel);
    pdel = NULL;

    return 0;
}

// 6.判断单向链表是否为空 1代表空 0代表非空
int IsEpLinkList(link_node_t *p)
{
    return p->next == NULL;
}

// 7.修改指定位置的数据 post 被修改的位置 data修改成的数据
int ChangePostLinkList(link_node_t *p, int post, datatype data)
{
    // 容错判断，如果为空，或者越界，那么修改失败
    if (IsEpLinkList(p) || post < 0 || post > LengthLinkList(p))
    {
        printf("无法删除 \n");
        return -1;
    }
    // 移动指针到需要修改的节点
    for (int i = 0; i <= post; i++)
    {
        p = p->next;
    }
    // 修改数据域，重新赋值
    p->data = data;

    return 0;
}

// 8.查找指定数据出现的位置 data被查找的数据 //search 查找
int SearchDataLinkList(link_node_t *p, datatype data)
{
    int n = 0;
    while (p->next != NULL)
    {
        p = p->next;
        if (p->data == data)
        {
            printf("%d 出现在下标为 %d 的位置\n", data, n);
            return 0;
        }
        n++;
    }
    printf("%d 未找到\n", data);
    return 0;
}

// 9.删除单向链表中出现的指定数据,data代表将单向链表中出现的所有data数据删除
int DeleteDataLinkList(link_node_t *p, datatype data)
// 写法一
{
    if (IsEpLinkList(p))
    {
        printf("表为空，无法删除 \n");
        return -1;
    }

    // 跨过头节点
    link_node_t *pdel = p->next;
    while (pdel != NULL)
    {
        // 判断节点的值是否为删除的数据
        if (pdel->data == data)
        {
            // 跨过被删除的节点
            p->next = pdel->next;
            // 释放被删除的节点
            free(pdel);
            pdel = NULL;
            // 此时p指针已经指向后一个节点，只需要移动pdel即可
            // 指针后移
            pdel = p->next;
        }
        else
        {
            // 指针后移
            p = p->next;
            pdel = p->next;
        }
    }
    return 0;
}

// 10.转置链表
// 将头节点与当前链表断开，断开前保存下头节点的下一个节点，保证后面的链表能够找到
// 定义一个q保存头节点的下一个节点，断开后相当于
// 遍历无头链表的所有节点，将每一个节点当做新节点插入空链表的下一个节点(头插)，
// 头插之前先用temp保存一下q的下一个节点以防插入完之后找不到后续节点
void ReverseLinkList(link_node_t *p)
{
    // 用于暂存头指针后的节点
    link_node_t *q = p->next;
    link_node_t *temp = NULL;
    // 断开头节点与链表
    p->next = NULL;
    while (q != NULL)
    {
        // 让temp暂存q的下一个节点，以防头插q之后找不到原来的链表
        temp = q->next;
        // 将q插入到头节点之后,先连后边，再连前边
        q->next = p->next;
        p->next = q;
        // 移动q到temp，继续遍历链表
        q = temp;
    }
}

// 11.清空单向链表
void ClearLinkList(link_node_t *p)
{
    link_node_t *pdel = NULL;
    while (p->next != NULL)
    {
        // pdel暂存要删除的节点
        pdel = p->next;
        // 跨过删除节点
        p->next = pdel->next;
        // 释放删除的节点
        free(pdel);
        pdel = NULL;
    }
    if (IsEpLinkList(p))
    {
        printf("表已清空\n");
    }
}

申屠武
关注
  • 21
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
有头单向链表
SUN_QL_的博客
04-12 191
有头单向链表
数据结构：无头单向链表的操作
m0_60391870的博客
04-16 427
一：什么是链表： 链表是一种物理存储结构上非连续存储结构，数据元素的逻辑顺序是通过链表中的引用链接次序实现的 （一）：分类： 二：无头单向非循环链表实现 注：此处的head表示第一个节点，并不是有头链表。有头的链表的头是一个傀儡节点。 ...
单向链表常见操作
m0_72049276的博客
11-18 32
【代码】单向链表常见操作。
数据结构上机练习——单链表的基本操作、头文件、类定义、main函数、多种链表算法的实现，含注释
Crocodile1006的博客
09-18 1405
数据结构、单链表的基本操作实现、头文件、类定义和多种算法的实现、创建空表///头插法创建n个元素的线性链表///一个带头节点的链表存放一组整数，设计一个算法删除值等于x的所有节点///计算线性表中值为偶数的节点个数///一个带头节点的单链表heada存放一组整数，设计分裂heada算法，偶数放在heada中，奇数放在headb中///main函数和源码实现、测试实现、LinkList.h、test.cpp
数据结构之单向有头链表的操作(纯代码及代码解释)
m0_68210771的博客
08-13 502
单向有头链表的详细代码和程序思路
数据结构与算法:单向链表实现与封装
08-26
"数据结构与算法：单向链表实现与封装" 在计算机科学中，数据结构是指计算机中存储、组织和管理数据的方式。链表是一种基本的数据结构，单向链表是指链表中的每个节点 chỉ指向下一个节点的数据结构。今天，我们将...
链表-使用Python实现链表数据结构.zip
03-13
本资源“链表-使用Python实现链表数据结构.zip”将详细介绍如何在Python中实现链表。 链表主要由节点（Node）组成，每个节点包含两部分：数据和指向下一个节点的引用。在Python中，我们可以用类来表示链表节点： `...
数据结构-链表.pdf
04-15
数据结构-链表 单向链表，双向链表、循环链表等
数据结构笔记：单向链表
12-22
分类目录——数据结构笔记 离散存储，手拉手，每一块有指向下一块的指针（形象描述，python中没有指针），就好像形成了一条链 一个元素包括两部分：value 和 next 链表与顺序表都是线性表 知识点补充 b = 20 a = 'a...
数据结构之---堆（2）
2301_81684056的博客
08-15 634
出堆是指将堆顶数据出堆。出堆完成后要保证剩余数据还是满足原来堆的性质。所以我们把堆顶数据和堆底最后一个数据交换，取出新堆底数据，之后通过向下调整算法将剩下的数据重新排列成一个堆。大堆经过出堆操作得出的数据是升序的小堆经过出堆操作得出的数据是降序的。
深入理解MySQL索引：原理、数据结构与优化策略
乙壳虫的博客
08-16 911
索引类似于一本书的目录，它可以帮助我们快速定位到需要的内容。没有索引时，MySQL 需要遍历整个表来找到目标记录，而索引通过构建特定的结构，可以加速查找的过程。索引的主要作用是提高数据库查询效率，减少数据库检索的行数，从而提升查询速度。B-Tree 索引：这是 MySQL 中最常见的索引结构，适用于大多数场景。B-Tree 是平衡树的一种，能够保持数据有序，从而加快查找速度。哈希索引（Hash Index）：通过将键映射为固定大小的哈希值来加速查找，适用于精确查找。
数据结构之树的存储结构
DKPT的博客
08-16 571
孩子链表表示法将树中所有节点存储在一个顺序表中，每个数据元素有两个域：数据域和存放该节点第一个孩子地址的指针域。同时，为树中每个节点构建一个单链表，链表中的节点也有两个域：存放该孩子节点在顺序表中的数组下标和指向下一个孩子的指针。对于完全二叉树，如果父节点的索引是i（假设从0开始计数），那么它的左子节点的索引是2i+1，右子节点的索引是2i+2。数组的第一个元素存储树的根节点。双亲表示法通过采用一维数组来存储树中的节点，其中每个节点被赋予一个结构体类型，包含数据域和父节点位置域（parent域）。
数据结构——时间复杂度和空间复杂度
2301_80373479的博客
08-15 924
带你了解时间复杂度和空间复杂度
【数据结构入门】二叉树之堆的实现
最新发布
KevinRay_0854的博客
08-20 1131
堆是一种重要的数据结构，常用于解决各种问题，如优先队列、排序算法、图算法等。堆具有很多特性，其中最常见的是最大堆和最小堆。最大堆中，每个节点的值都大于等于其子节点的值，而最小堆则相反，每个节点的值都小于等于其子节点的值。在本文中，我们将详细介绍堆的概念、性质和操作。我们将以一个具体的例子来说明堆的构建和调整过程，并通过图示展示堆的结构。最后，我们还将讨论堆在实际应用中的一些常见用途和算法。通过学习堆，您将能够更好地理解和应用这一重要的数据结构。
构建业务可观测性：统一数据结构的重要性
wj_wjs的博客
08-15 668
随着业务流程的日益复杂化和数据来源的多样化，如何有效地监控和分析这些数据，成为了企业提升竞争力的关键。观测云平台的统一数据结构，为企业提供了一个标准化的数据管理框架，有助于企业更好地遵守数据保护法规，保护客户数据的安全和隐私。通过建立统一的数据结构，企业能够确保不同来源和类型的数据在格式、定义和语义上的一致性，从而实现数据的无缝整合和高效分析。通过建立统一的数据结构，观测云平台使得不同部门能够使用相同的数据语言进行沟通，从而加强了跨部门的协作和信息共享。首先，统一数据结构为数据采集提供了标准化的框架。
初阶数据结构之直接选择排序和快速排序
Mr_Xuhhh的博客
08-17 655
1.直接选择排序思考⾮常好理解，但是效率不是很好。实际中很少使⽤2.时间复杂度： O(N。
《数据结构（C语言版）第二版》第六章-图（6.6 图的应用——6.6.1 最小生成树）
qq_44883214的博客
08-18 101
32767100。
数据结构（邓俊辉）学习笔记】优先级队列 05——完全二叉堆：删除与下滤
weixin_44399845的博客
08-17 594
完全二叉堆：删除与下滤
数据结构----单向链表
03-27
单向链表是一种常见的数据结构，它由一系列节点组成，每个节点包含两部分：数据和指向下一个节点的指针。每个节点只知道下一个节点的位置，而不知道前一个节点的位置。 单向链表的特点是插入和删除操作的效率较高，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值