数据结构链表

最新推荐文章于 2024-08-16 08:54:14 发布
最新推荐文章于 2024-08-16 08:54:14 发布
阅读量300 收藏 1
点赞数 10
文章标签： 数据结构 链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_58356691/article/details/139065069
版权

1.概念

逻辑结构：线性结构

存储结构：链式结构

链表又分为有头节点和无头节点的，每种又细分为单向的，循环的，双向的。

以单向链表为例。

有头节点单向链表示意图：

2.对链表的操作

1.创建链表节点 √

2.清空链表 √

3.销毁链表 √

4.向链表中插入元素(头插) √

5.向链表中插入元素(尾插) √

6.向链表中插入元素(任意位置插入) √

7.在链表中删除元素(头删) √

8.在链表中删除元素(尾删) √

9.在链表中删除元素(任意位置删除) √

10.修改链表中指定位置的元素 √

11.查找链表中指定位置的元素 √

12.两个链表的合并 √

13.链表的排序 √

14.链表的翻转 √

15.链表的剔重 √

16.遍历打印链表中所有元素----看现象用的 √

3.链表操作流程图

（1）链表插入节点流程图

（2）链表删除节点流程图

（3）两个链表合并的流程图

（4）链表翻转流程图

（5）链表排序流程图

也是采用冒泡排序的思想

（6）链表剔重流程图

4.代码实现

link_list.h

#ifndef __LINK_LIST_H__
#define __LINK_LIST_H__

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

//链表节点的结构体
typedef struct _Node{
    int data;           //数据域 此处以int为例 实际使用时用实际类型替换即可
    struct _Node *next; //指针域 此处不能使用 node_t 因为还不认识呢
}node_t;

int create_node(node_t **p, int data);
int insert_list_by_head(node_t *phead, int data);
int print_list(node_t *phead);
int insert_list_by_tail(node_t *phead, int data);
int insert_list_by_pos(node_t *phead, int pos, int data);
int delete_list_by_head(node_t *phead);
int delete_list_by_tail(node_t *phead);
int delete_list_by_pos(node_t *phead, int pos);
int modify_list_by_pos(node_t *phead, int pos, int new_data);
int search_list_by_pos(node_t *phead, int pos, int *num);
int clean_list(node_t *phead);
int destroy_list(node_t **phead);
int merge_list(node_t *phead1, node_t **phead2);
int reverse_list(node_t *phead);
int sort_list(node_t *phead);
int tichong_list(node_t *phead);

#endif

link_list.c

#include "link_list.h"

//创建链表节点的函数
int create_node(node_t **p, int data){
    if(NULL == p){
        printf("入参为NULL\n");
        return -1;
    }
    *p = (node_t *)malloc(sizeof(node_t));
    if(NULL == *p){
        printf("内存分配失败\n");
        return -1;
    }
    //初始化新节点
    (*p)->data = data;
    (*p)->next = NULL;
    return 0;
}

//向链表中插入元素(头插)
int insert_list_by_head(node_t *phead, int data){
    if(NULL == phead){
        printf("入参为NULL\n");
        return -1;
    }
    node_t *pnew = NULL;
    create_node(&pnew, data);
    //执行头插操作
    pnew->next = phead->next;
    phead->next = pnew;
    return 0;
}

//遍历链表
int print_list(node_t *phead){
    if(NULL == phead){
        printf("入参为NULL\n");
        return -1;
    }
    node_t *ptemp = phead;//备份一下头结点
                        //防止函数内部后面使用时 找不到链表头了
    while(NULL != ptemp->next){
        ptemp = ptemp->next;
        printf("%d  ", ptemp->data);
    }
    printf("\n");
    return 0;
}

//向链表中插入元素(尾插)
int insert_list_by_tail(node_t *phead, int data){
    if(NULL == phead){
        printf("入参为NULL\n");
        return -1;
    }
    //先遍历链表 找到最后一个节点
    node_t *ptemp = phead;
    while(NULL != ptemp->next){
        ptemp = ptemp->next;
    }
    node_t *pnew = NULL;
    create_node(&pnew, data);
    ptemp->next = pnew;
    return 0;
}

//向链表中插入元素(任意位置插入)
int insert_list_by_pos(node_t *phead, int pos, int data){
    if(NULL == phead){
        printf("入参为NULL\n");
        return -1;
    }
    if(pos < 0){
        printf("插入位置不合理 插入失败\n");
        return -1;
    }
    node_t *ptemp = phead;
    int i = 0;
    for(i = 0; i < pos; i++){
        ptemp = ptemp->next;
        if(NULL == ptemp){
            break;
        }
    }
    if(i < pos){
        printf("插入位置不合理 插入失败\n");
        return -1;
    }
    //执行插入操作
    node_t *pnew = NULL;
    create_node(&pnew, data);
    pnew->next = ptemp->next;
    ptemp->next = pnew;
    return 0;
}

//在链表中删除元素(头删)
int delete_list_by_head(node_t *phead){
    if(NULL == phead){
        printf("入参为NULL\n");
        return -1;
    }
    if(NULL == phead->next){
        printf("链表为空 删除失败\n");
        return -1;
    }
    node_t *pdel = phead->next;
#if 1
    phead->next = phead->next->next;
#else
    phead->next = pdel->next;
#endif
    free(pdel);
    pdel = NULL;
    return 0;
}

//在链表中删除元素(尾删)
int delete_list_by_tail(node_t *phead){
    if(NULL == phead){
        printf("入参为NULL\n");
        return -1;
    }
    if(NULL == phead->next){
        printf("链表为空 删除失败\n");
        return -1;
    }
    //遍历链表 找到倒数第二个数据节点
    node_t *ptemp = phead;
    while(NULL != ptemp->next->next){
        ptemp = ptemp->next;
    }
    free(ptemp->next);
    ptemp->next = NULL;
    return 0;
}

//在链表中删除元素(任意位置删除)
int delete_list_by_pos(node_t *phead, int pos){
    if(NULL == phead){
        printf("入参为NULL\n");
        return -1;
    }
    if(NULL == phead->next){
        printf("链表为空 删除失败\n");
        return -1;
    }
    if(pos < 0){
        printf("删除位置不合理 删除失败\n");
        return -1;
    }
    node_t *ptemp = phead;
    int i = 0;
    for(i = 0; i < pos; i++){
        ptemp = ptemp->next;
        if(NULL == ptemp->next){
            break;
        }
    }
    if(i < pos){
        printf("删除位置不合理 删除失败\n");
        return -1;
    }
    //执行删除操作
    node_t *pdel = ptemp->next;
    ptemp->next = pdel->next;
    free(pdel);
    pdel = NULL;
    return 0;
}

//修改链表中指定位置的元素
int modify_list_by_pos(node_t *phead, int pos, int new_data){
    if(NULL == phead){
        printf("入参为NULL\n");
        return -1;
    }
    if(NULL == phead->next){
        printf("链表为空 修改失败\n");
        return -1;
    }
    if(pos < 0){
        printf("修改位置不合理 修改失败\n");
        return -1;
    }
    node_t *ptemp = phead;
    int i = 0;
    for(i = 0; i < pos; i++){
        ptemp = ptemp->next;
        if(NULL == ptemp->next){
            printf("修改位置不合理 修改失败\n");
            return -1;
        }
    }
    //执行修改操作
    ptemp->next->data = new_data;
    return 0;
}

//查找链表中指定位置的元素
int search_list_by_pos(node_t *phead, int pos, int *num){
    if(NULL == phead || NULL == num){
        printf("入参为NULL\n");
        return -1;
    }
    if(NULL == phead->next){
        printf("链表为空 没有数据节点\n");
        return -1;
    }
    if(pos < 0){
        printf("查找的位置没有数据\n");
        return -1;
    }
    node_t *ptemp = phead;
    int i = 0;
    for(i = 0; i < pos; i++){
        ptemp = ptemp->next;
        if(NULL == ptemp->next){
            printf("查找的位置没有数据\n");
            return -1;
        }
    }
    //执行查找操作
    *num = ptemp->next->data;
    return 0;
}

//清空链表
int clean_list(node_t *phead){
    if(NULL == phead){
        printf("入参为NULL\n");
        return -1;
    }
    //循环头删
    node_t *pdel = NULL;
    while(NULL != phead->next){
        pdel = phead->next;
        phead->next = pdel->next;
        free(pdel);
    }
    pdel = NULL;
    return 0;
}

//销毁链表
int destroy_list(node_t **phead){
    if(NULL == phead || NULL == *phead){
        printf("入参为NULL\n");
        return -1;
    }
    //为了防止内存泄漏 应该先清空再销毁
    clean_list(*phead);
    free(*phead);
    *phead = NULL;
    return 0;
}

//两个链表合并
int merge_list(node_t *phead1, node_t **phead2){
    if(NULL == phead1 || NULL == phead2 || NULL == *phead2){
        printf("入参为NULL\n");
        return -1;
    }
    node_t *ptemp = phead1;
    while(NULL != ptemp->next){
        ptemp = ptemp->next;
    }
    ptemp->next = (*phead2)->next;
    free(*phead2);
    *phead2 = NULL;
    return 0;
}

//链表的翻转
int reverse_list(node_t *phead){
    if(NULL == phead){
        printf("入参为NULL\n");
        return -1;
    }
    if(NULL == phead->next){
        printf("链表为空 无需翻转\n");
        return -1;
    }
    if(NULL == phead->next->next){
        printf("只有一个节点 无需翻转\n");
        return -1;
    }
    node_t *p = phead->next;
    node_t *q = p->next;
    p->next = NULL;
    while(NULL != p){
        p = q->next;
        q->next = phead->next;
        phead->next = q;
        q = p;
    }
    return 0;
}

//链表的排序  以升序为例
int sort_list(node_t *phead){
    if(NULL == phead){
        printf("入参为NULL\n");
        return -1;
    }
    if(NULL == phead->next){
        printf("链表为空 无需排序\n");
        return -1;
    }
    if(NULL == phead->next->next){
        printf("只有一个节点 无需排序\n");
        return -1;
    }
    node_t *p = phead->next;
    node_t *q = NULL;
    int temp = 0;
    while(NULL != p->next){
        q = p->next;
        while(NULL != q){
            if(p->data > q->data){
                temp = p->data;
                p->data = q->data;
                q->data = temp;
            }
            q = q->next;
        }
        p = p->next;
    }
    return 0;
}

//链表的剔重
int tichong_list(node_t *phead){
    if(NULL == phead){
        printf("入参为NULL\n");
        return -1;
    }
    if(NULL == phead->next){
        printf("链表为空 无需剔重\n");
        return -1;
    }
    if(NULL == phead->next->next){
        printf("只有一个节点 无需剔重\n");
        return -1;
    }
    node_t *p = phead->next;
    node_t *q = NULL;
    node_t *m = NULL;//用来保存q的前一节点 删除q时使用
    while(NULL != p){
        m = p;
        q = p->next;
        while(NULL != q){
            if(p->data == q->data){
                m->next = q->next;
                free(q);
                q = m->next;
            }else{
                m = q;
                q = q->next;
            }
        }
        p = p->next;
    }
    return 0;
}

main.c    调试用的

#include "link_list.h"

int main(int argc, const char *argv[])
{
    node_t *phead = NULL;
    create_node(&phead, -1);
    printf("phead = %p\n", phead);//非NULL

    //测试头插
    insert_list_by_head(phead, 10);
    insert_list_by_head(phead, 20);
    insert_list_by_head(phead, 30);
    print_list(phead); // 30 20 10

    //测试尾插
    insert_list_by_tail(phead, 40);
    insert_list_by_tail(phead, 50);
    insert_list_by_tail(phead, 60);
    print_list(phead); // 30 20 10 40 50 60

    //测试任意位置插入
    insert_list_by_pos(phead, 7, 100);//不合理
    insert_list_by_pos(phead, 6, 100);
    insert_list_by_pos(phead, 3, 200);
    print_list(phead); // 30 20 10 200 40 50 60 100

    //测试头删
    delete_list_by_head(phead);
    delete_list_by_head(phead);
    print_list(phead); // 10 200 40 50 60 100
    
    //测试尾删
    delete_list_by_tail(phead);
    delete_list_by_tail(phead);
    print_list(phead); // 10 200 40 50

    //测试任意位置删除
    delete_list_by_pos(phead, 4);//不合理
    delete_list_by_pos(phead, 3);
    delete_list_by_pos(phead, 1);
    print_list(phead); // 10 40

    //测试修改
    modify_list_by_pos(phead, 2, 20);//不合理
    modify_list_by_pos(phead, 1, 20);
    print_list(phead); // 10 20

    //测试查找
    int num = 0;
    search_list_by_pos(phead, 2, &num);//不合理
    search_list_by_pos(phead, 1, &num);
    printf("num = %d\n", num); //20

    //测试清空
    clean_list(phead);
    print_list(phead); // 没有元素了

    //测试销毁
    destroy_list(&phead);
    printf("phead = %p\n", phead);//NULL

    //测试合并
    create_node(&phead, -1);
    insert_list_by_tail(phead, 10);
    insert_list_by_tail(phead, 20);
    insert_list_by_tail(phead, 30);
    node_t *phead2 = NULL;
    create_node(&phead2, -1);
    insert_list_by_tail(phead2, 40);
    insert_list_by_tail(phead2, 50);
    insert_list_by_tail(phead2, 60);
    merge_list(phead, &phead2);
    print_list(phead); // 10 20 30 40 50 60
    printf("phead2 = %p\n", phead2);//NULL

    //测试翻转
    reverse_list(phead);
    print_list(phead); // 60 50 40 30 20 10

    //测试排序
    sort_list(phead);
    print_list(phead); // 10 20 30 40 50 60

    //测试剔重
    insert_list_by_pos(phead, 2, 10);
    insert_list_by_pos(phead, 5, 10);
    insert_list_by_pos(phead, 7, 20);
    insert_list_by_tail(phead, 60);
    insert_list_by_tail(phead, 60);
    insert_list_by_tail(phead, 60);
    print_list(phead); // 10 20 10 30 40 10 50 20 60 60 60 60
    tichong_list(phead);
    print_list(phead); // 10 20 30 40 50 60

    destroy_list(&phead);

    return 0;
}
小齐勇闯天涯
关注
  • 10
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
数据结构链表：单链表的代码实现
03-20
本文通过数据结构教程的方法利用C++语言写了单链表的各项功能 功能包括 1.链表的初始化 2.链表的查找和判断是否为空表 3.插入 4.取值 5.插入（尾插法） 6.链表的输出 7.//删除指定元素 8.//链表的释放 其中有着详细...
数据结构链表入门.docx
01-13
《数据结构链表入门》 链表是一种基础且重要的数据结构，在计算机科学中扮演着不可或缺的角色。本资料主要介绍链表的基本概念、操作以及如何在C++中实现链表。以下将详细阐述链表的原理及其在代码中的体现。 1. ...
C语言链表超详解
热门推荐
k666499436的博客
05-17 11万+
详细对比顺序表与链表的区别， 实现单链表，与双向带头循环链表，以及各中类型的链表
数据结构 -- 链表详解
hu_143的博客
04-27 2343
链表详解，重点讲解两种常用的链表，看到就是赚到！！！
数据结构之——链表
xqx_999的博客
10-06 4284
链表的介绍，单链表和双向链表的接口实现。
数据结构-链表
一个努力拼搏的人
11-13 1718
这里用typedef重新定义了int类型的名称，方便以后更换类型。这里用typedef重新定义了int类型的名称，方便以后更换类型。{}DL;
数据结构之链表
CSDN全栈领域优秀博主，阿里云博客专家，工信部权威认证物联网技术开发工程师，曾30分钟高分通过C语言二级，两天手撸代码完成EasyX飞机大战，靠接软件私活一个月换苹果电脑
01-18 3938
数据结构之链表
Educoder头歌数据结构链表及其应用
qq_50848214的博客
11-05 1万+
头歌实践平台答案educoder 数据结构-链表及其应用 第1关：链表的实现之查找功能 /************************************************************* 链表的实现之查找功能 实现文件 更新于2020年4月21日 **************************************************************/ void LL_GetAt(LinkList L, int i, ElemType &amp
java数据结构-链表详解
m0_63526467的博客
05-04 4099
文章目录1.数据结构-链表详解1.1单链表1.1.1单链表节点的尾部添加1.1.2单链表节点的自动排序添加1.1.3单链表节点的修改1.1.4单链表节点的删除1.2单链表面试题1.2.1单链表的有效节点个数1.2.2单链表倒数第k个结点1.2.3单链表反转1.2.4单链表逆序打印1.3双向链表1.3.1双向链表介绍1.3.2双向链表增删改查1.4单向环形链表1.4.1约瑟夫（Josephu）环问题 1.数据结构-链表详解 链表可分为三类： 单链表 双向链表 循环列表 下面具体分析三个链表的应用。 1.1
数据结构-链表篇
qq_16268979的博客
01-10 1万+
数据结构-链表篇
【数据结构】链表的学习总结
Pursue quality, not quantity.
08-07 2994
初阶_数据结构
数据结构——链表（Linked List）
jishuxhengjiu的博客
08-31 1万+
使用单向环形链表解决Josephu问题，用不带头结点的单向循环链表先构成一个有n个节点的链表，然后由k节点起从1开始计数，直到第m时，对应节点删除，然后从被删除的下一个节点开始从1开始计数，直到最后一个节点被删除结束算法。2.temp.next = temp.next.next，也就是说需要删除节点的前一个节点本来指向的是删除节点，然后我们使其指向删除节点的下一个节点，直接跳过删除节点，这样该节点也就相当于被删除了。例如N=6，M=5，被杀掉的顺序是：5，4，6，2，3。1.单链表是以节点的方式来存储的。.
lb.rar_数据结构 链表
09-20
本资源"lb.rar_数据结构 链表"提供了一些关于链表的C++实现，对学习数据结构的初学者尤其有帮助。 链表是一种线性数据结构，与数组不同，它的元素并不在内存中连续存储。每个元素（节点）包含两部分：数据域，用于...
湖南大学数据结构链表实验1.zip
03-08
5. 链表应用：链表广泛应用于各种数据结构（如栈、队列、哈希表）和算法（如排序、搜索）中。 通过这个实验，你将有机会亲手实践这些概念，加深对链表的理解，并提升编程技能。同时，对比两种不同的链表实现（面向...
linear_list_数据结构链表例程_源码
10-02
在本项目“linear_list_数据结构链表例程_源码”中，我们将会探讨如何在Visual Studio环境下实现一个灵活的链表结构。 链表与数组不同，数组在内存中是连续存储的，而链表的每个元素（节点）分散在内存的不同位置，...
图解大顶堆的构建、排序过程
sagima_sdu的博客
08-12 512
开始，
【长度最小的子数组】python刷题记录
m0_73629042的博客
08-12 253
【代码】【长度最小的子数组】python刷题记录。
深入理解MySQL索引：原理、数据结构与优化策略
最新发布
乙壳虫的博客
08-16 644
索引类似于一本书的目录，它可以帮助我们快速定位到需要的内容。没有索引时，MySQL 需要遍历整个表来找到目标记录，而索引通过构建特定的结构，可以加速查找的过程。索引的主要作用是提高数据库查询效率，减少数据库检索的行数，从而提升查询速度。B-Tree 索引：这是 MySQL 中最常见的索引结构，适用于大多数场景。B-Tree 是平衡树的一种，能够保持数据有序，从而加快查找速度。哈希索引（Hash Index）：通过将键映射为固定大小的哈希值来加速查找，适用于精确查找。
知识改变命运 数据结构【洗牌算法(顺序表)】
2402_84062064的博客
08-13 284
a：这个类里面包括一个String类型的数据和int数据类型的数据分别存储花色和牌号b：创建一个构造方法对牌号和花色赋值·c：进行toString重写a：创造一个数组里面包含了四种花色b：利用for循环对花色与牌号结合 然后赋值给牌中。
数据结构链表操作大全，面向对象封装
数据结构链表操作大全是一种在面向对象编程中对链表进行操作的封装方法。链表是一种重要的数据结构，它可以动态地存储和处理数据。本文将介绍链表的创建、插入、删除、查找等操作，并在面向对象的方法上进行封装。 ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值