重温数据结构之链表二——C语言实现

最新推荐文章于 2024-09-22 13:00:38 发布
最新推荐文章于 2024-09-22 13:00:38 发布
阅读量324 收藏
点赞数
分类专栏： 算法 文章标签： 数据结构 线性表 单链表 数据 内存
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/itheimach/article/details/59708030
版权

链表

链表属于线性表的一种，不同于顺序表数据的内存地址是连续的，我们就在该数据结构上加一个属性，指向前后数据的内存地址，这样就将数据一串一串的连起来了，这就是链表！

链表分类

链表是有一系列的内存地址不连续的节点组成的，每个节点有两部分组成：数据域，指针域。数据域表示存储的数据，指针域指向另外一个节点，连接成串！
链表有几种：

单链表：头尾不相连，节点有下一个节点的指针（除去尾节点）
双链表：头尾不相连，节点指向上一个以及下一个节点的指针（头节点只有后继，尾节点只有前驱）
单向循环链表：头尾相连的链表，尾节点指向头节点，形成环
双向循环链表：头尾相连的链表，所有节点都有前驱以及后继，形成双向环，可以前后遍历！

简单实现

单链表实现

#include <stdio.h>
#include <malloc.h>

//单链表实现
typedef struct queue_node {

    void *data;
    struct queue_node* next;
} node;

static int count;
static node *phead = NULL;
static node* create_node(void *data) {

    node* node = malloc(sizeof(node));
    if (!node) {

        return NULL;
    }
    node->data = data;
    return node;
}

//创建链表,成功返回0,失败返回-1
int create_queue() {

    node* node = create_node(null);
    if (!node) {

        return -1;
    }
    phead = node;
    phead->next = NULL;
    count = 0;
    return 0;
}

// 链表是否为空
int queue_is_empty() {

    return count == 0;
}

// 获取链表的长度
int queue_size() {

    return count;
}

static node* get_node(int index) {

    if (index < 0 || index >= count) {

        return NULL;
    }

    int i = 0;
    node* node = phead->next;
    while (i < index) {

        node = node->next;
        i++;
    }

    return node;
}

static node* get_first_node() {

    return get_node(0);
}

static node* get_last_node() {

    return get_node(count - 1);
}

//获取index位置的元素值
void* queue_get(int index) {

    if (index < 0 || index >= count) {

        return NULL;
    }

    node* node = get_node(index);
    if (!node) {
        return NULL;
    }
    return node->data;
}

// 获取链表中第1个元素的值
void* queue_get_first() {

    node* node = get_node(0);
    if (!node) {

        return NULL;
    }
    return node->data;
}

void* queue_get_last() {

    node* node = get_node(count - 1);
    if (!node) {

        return NULL;
    }
    return node->data;
}

//向链表中插入元素,成功返回0,失败返回-1
int queue_insert(int index, void* data) {

    if (index < 0 || index > count) {

        return -1;
    }

    //新的元素
    node* newnode = create_node(data);
    if (!newnode) {

        return -1;
    }

    if (index == 0) {
        // 插入头部
        node* first_node = get_first_node();
        phead->next = newnode;
        newnode->next = first_node;
    } else if (index == count) {

        // 插入末尾
        node* lastnode = get_last_node();
        lastnode->next = newnode;
        newnode->next = NULL;
    } else {

        // 中间插入
        node* nodepre = get_node(index - 1);
        nodepre->next = newnode;
        newnode->next = nodepre->next;
    }

    count++;
    return 0;
}

int queue_insert_first(void *data) {

    return queue_insert(0, data);
}

int queue_append_last(void *pval) {

    return queue_insert(count, data);
}

int queue_delete(int index) {

    if (index < 0 || index >= count) {

        return -1;
    }

    if (index == 0) {

        // 删除首个元素
        node* nodeindex = get_node(index);
        phead->next = nodeindex->next;
        free(nodeindex);
    } else {

        node* prenode = get_node(index - 1);
        node* current = nodenode->next;
        prenode->next = current->next;
        free(current);
    }

    count--;
    return 0;
}

int queue_delete_first() {

    return queue_delete(0);
}

int queue_delete_last() {

    return queue_delete(count - 1);
}

int destroy_queue() {

    if (!phead) {

        return -1;
    }
    node* node = phead->next;
    node* q = node;
    while (node) {

        q = node;
        node = node->next;
        free(q);
    }

    free(phead);
    count = 0;
}

双链表实现

#include <stdio.h>
#include <malloc.h>

//双链表实现
typedef struct queue_node {

    void *data;
    struct queue_node* next;
    struct queue_node* pre;
} node;

static int count;
static node *phead = NULL;

// 创建node
static node* create_node(void *data) {

    node* node = malloc(sizeof(node));
    if (!node) {

        return NULL;
    }
    node->data = data;
    node->pre = node->next = NULL;
    return node;
}

// 新建“双向链表”。成功，返回0；否则，返回-1
int create_queue() {

    node* node = create_node(NULL);
    if (!node) {

        return -1;
    }

    phead = node;
    count = 0;
}

// “双向链表是否为空”。为空的话返回1；否则，返回0。
int queue_is_empty() {

    return count == 0;
}
// 返回“双向链表的大小”
int queue_size() {

    return count;
}
// 获取“双向链表中第index位置的元素”。成功，返回节点指针；否则，返回NULL。
void* queue_get(int index) {

    if (index < 0 || index >= count) {

        return NULL;
    }

    int i = 0;
    node * node = phead->next;
    while (i < index) {

        node = node->next;
        i++;
    }

    return node;
}
// 获取“双向链表中第1个元素”。成功，返回节点指针；否则，返回NULL。
void* queue_get_first() {

    return queue_get(0);
}
// 获取“双向链表中最后1个元素”。成功，返回节点指针；否则，返回NULL。
void* queue_get_last() {

    return queue_get(count - 1);
}
// 将“value”插入到index位置。成功，返回0；否则，返回-1。
int queue_insert(int index, void *value) {

    if (index < 0 || index > count) {

        return -1;
    }

    // 新建节点
    node* newnode = create_node(value);
    if (!newnode) {

        return -1;
    }

    if (index == 0) {

        // 在首个位置插入
        node* firstnode = phead->next;
        phead->next = newnode;
        newnode->pre = phead;
        newnode->next = firstnode;
        firstnode->pre = newnode;
    } else if (index == count) {

        // 在末尾插入
        node* lastnode = queue_get(index - 1);
        lastnode->next = newnode;
        newnode->pre = lastnode;
        newnode->next = NULL;

    } else {

        //在中间插入
        node* currentnode = queue_get(index);
        node* prenode = currentnode->pre;

        prenode->next = newnode;
        newnode->pre = prenode;
        newnode->next = currentnode;
        currentnode->pre = newnode;
    }
    count++;
    return 1;
}
// 将“value”插入到表头位置。成功，返回0；否则，返回-1。
int queue_insert_first(void *pval) {

    return queue_insert(0, pval);
}
// 将“value”插入到末尾位置。成功，返回0；否则，返回-1。
int queue_append_last(void *pval) {

    return queue_insert(count, pval);
}
// 删除“双向链表中index位置的节点”。成功，返回0；否则，返回-1
int queue_delete(int index) {

    if (index < 0 || index >= count) {

        return -1;
    }
    node* node = queue_get(index);
    node* prenode = node->pre;
    prenode->next = node->next;
    node->next->pre = prenode;
    free(node);
    count--;
    return 0;
}

// 删除第一个节点。成功，返回0；否则，返回-1
int queue_delete_first() {

    return queue_delete(0);
}

// 删除组后一个节点。成功，返回0；否则，返回-1
int queue_delete_last() {

    return queue_delete(count - 1);
}

// 撤销“双向链表”。成功，返回0；否则，返回-1
int destroy_queue() {

    if (!phead) {

        return -1;
    }
    node* node = phead->next;
    node * p;
    while (node) {

        p = node;
        node = node->next;
        free(p);
    }

    free(phead);
    count = 0;
}

双向循环链表实现

#include <stdio.h>
#include <malloc.h>

//双向循环链表实现
typedef struct queue_node {

    void *data;
    struct queue_node* next;
    struct queue_node* pre;
} node;

static int count;
node* phead;

// 新建“双向链表”。成功，返回0；否则，返回-1
int create_queue() {

    phead = create_node(NULL);
    if (!node) {

        return NULL;
    }
    count = 0;
    return 0;
}

node * create_node(void *data) {

    node* node = malloc(sizeof(node));
    if (!node) {

        return NULL;
    }
    node->data = data;
    node->pre = node->next = NULL;
    return node;
}

// “双向链表是否为空”。为空的话返回1；否则，返回0。
int queue_is_empty() {

    return count == 0;
}
// 返回“双向链表的大小”
int queue_size() {

    return count;
}
// 获取“双向链表中第index位置的元素”。成功，返回节点指针；否则，返回NULL。
void* queue_get(int index) {

    if (index < 0 || index >= count) {

        return NULL;
    }

    // 这里可以优化
    node* firstnode = phead->next;
    int i = 0;
    while ((i++) < index) {

        firstnode = firstnode->next;
    }

    return firstnode->data;
}
// 获取“双向链表中第1个元素”。成功，返回节点指针；否则，返回NULL。
void* queue_get_first() {

    return queue_get(0);
}
// 获取“双向链表中最后1个元素”。成功，返回节点指针；否则，返回NULL。
void* queue_get_last() {

    return queue_get(count - 1);
}
// 将“value”插入到index位置。成功，返回0；否则，返回-1。
int queue_insert(int index, void *pval) {

    if (index < 0 || index > count) {

        return -1;
    }

    node* newnode = create_node(pval);
    if (!newnode) {

        return -1;
    }
    node* nodeindex = queue_get(index);
    if (!nodeindex) {
        // index=count 在末尾插入
        node* lastnode = phead->pre;
        lastnode->next = newnode;
        newnode->pre = lastnode;
        newnode->next = phead;
        phead->pre = newnode;
    } else {
        // 不为空，在其他位置插入
        node* prenode = nodeindex->pre;
        prenode->next = newnode;
        newnode->pre = prenode;
        newnode->next = nodeindex;
        nodeindex->pre = newnode;
    }
    count++;
    return 0;
}
// 将“value”插入到表头位置。成功，返回0；否则，返回-1。
int queue_insert_first(void *pval) {

    return queue_insert(0, pval);
}
// 将“value”插入到末尾位置。成功，返回0；否则，返回-1。
int queue_append_last(void *pval) {

    return queue_insert(count, pval);
}
// 删除“双向链表中index位置的节点”。成功，返回0；否则，返回-1
int queue_delete(int index) {

    if (index < 0 || index >= count) {

        return -1;
    }

    node* indexnode = queue_get(index);
    node* prenode = indexnode->pre;
    node* nextnode = indexnode->next;
    prenode->next = nextnode;
    nextnode->pre = prenode;
    free(indexnode);
    count--;
    return 0;
}
// 删除第一个节点。成功，返回0；否则，返回-1
int queue_delete_first() {

    return queue_delete(0);
}
// 删除组后一个节点。成功，返回0；否则，返回-1
int queue_delete_last() {

    return queue_delete(count - 1);
}

// 撤销“双向链表”。成功，返回0；否则，返回-1
int destroy_queue() {

    if (!phead) {

        return -1;
    }
    node* firstnode = phead->next;
    node* p;
    while (firstnode) {

        p = firstnode;
        firstnode = firstnode->next;
        free(p);
    }
    free(phead);
    phead = NULL;
    count = 0;
    return 0;
}
永远的红姐
关注
专栏目录
链表的c语言实现（二）
leton2008的专栏
04-30 2255
单链表的c语言实现(1)一、单链表的建立有了动态内存分配的基础，要实现链表就不难了。所谓链表，就是用一组任意的存储单元存储线性表元素的一种数据结构。链表又分为单链表、双向链表和循环链表等。我们先讲讲单链表。所谓单链表，是指数据接点是单向排列的。一个单链表结点，其结构类型分为两部分：1、数据域：用来存储本身数据2、链域或称为指针域：用来存储下一个结点地址或者说指向其直接后继的指针。例：typedef
数据结构与C语言实现（一）——链表及两个实例
Sonihr的犀牛园
10-12 351
//用数组实现线性表 /* #include #include #define MAXSIZE 11 struct LNode { char data[MAXSIZE]; int last; }L; typedef struct LNode * PList; void List_Adress()//测试结构体及内部元素地址 { PList PtrL = &L; printf(
使用C语言实现队列
cangck_x的博客
06-29 860
#include &lt;stdio.h&gt;#include &lt;malloc.h&gt;typedef struct queue_node { struct queue_node* prev; struct queue_node* next; void *p;//节点的值} node;// 表头static node *phead = NULL;static int count = 0;...
数据结构与算法的重温之旅（四）——链表
Tank_in_the_street的博客
05-25 425
一、链表概念 还记得上一篇文章中数组的概念吗，其实数组和链表都是线性表的一种，不过数组与链表有一点不同的是，链表是不需要连续内存空间来存储，它通过指针将一组零散的内存块串联起来使用。链表它的结构五花八门，常用的三种链表结构分别是单链表、双向链表、循环链表和双向循环链表。首先我们先将最简单的单链表。 二、单链表 上面有讲，链表是通过指针将一组零散的内存块串联在一起，其中这个内存块我们称之为链表...
数据结构与算法的重温之旅（三）——数组
Tank_in_the_street的博客
05-23 221
本系列所有文章的代码都是用JavaScript实现，之所以用JavaScript实现是因为它可以直接在浏览器宿主中运行代码，即在浏览器中按f12打开控制台，选择console按钮，在下面空白的文本框把本例的代码黏贴上去回车即可运行。方便各位同学学习和调试。 一、前言 数组这个概念相信各位同学在日常写代码的时候肯定会经常用到，我们通常用数组作为容器来存储数据。基本上每一种编程语言都有这种数据...
循环链表——约瑟夫环实现
qq_33851322的博客
05-08 311
近期重温数据结构，发现有不少书籍没有将成品可运行的数据结构代码放出，所以在这挖个坑，后期会将常见数据结构以C语言形式实现，并且尽可能让只看了书但是代码能力较弱的读者也能看懂实现。本人能力有限，不足之处还请大家多多指出。 下面放出循环链表实现的约瑟夫环，运行环境为vs2019，无报错 #include<stdio.h> #include<stdlib.h> #pragma warning(disable:4996)； //约瑟夫环问题实现 typedef struct Node {
链表的两种创建方法——头插法与尾插法
weixin_45728685的博客
03-12 6172
链表创建的两种方法 引言 ​ 首先讲述了我自己在动态实现数据结构的时候遇到的大坑结构体指针问题，随后就是头插法和尾插法的介绍。 结构体指针 引言 ​ 首先需要讲述的是一个让我改了一天半的bug。实际上半天的时候就已经发现了二级指针的问题，但是并没有深究，以为是自己对指针运用不够熟练，就略微重温了一下指针的比较浅层的相关内容，然后第二天的两个程序链栈和链队列都出现了段错误和垃圾值问题，改了半天才发现...
基于C语言的个人信息管理系统
陈宝子的博客
07-17 5509
实训项目-个人信息管理系统 文章目录实训项目-个人信息管理系统前言一、前期相关准备1、 编译软件安装2、 基本技术掌握2.1、 信息存储2.1.1、 临时存储2.1.2、 长期存储2.2、 查找排序2.3、 线性表操作2.4、 文件操作2.5、 代码书写规范二、需求分析三、难点疑点分析1、实现读取文件并写入链表中( 控制size )2、中文如何实现排序3、多文件如何联系起来四、核心代码思想和实现1、登陆注册2、管理员模块3、个人中心4、日程管理5、通讯录管理6、健身管理7、财务管理五、总结与收获六、白嫖源码
全国大学生计算机技能应用（2020年）——C++科目决赛程序设计题解
陆海潘江的博客
07-13 2466
       早上10点，准时开始比赛。10:00~11:30一个半小时的时间，需要解答13道不定项选择题、2道程序填空题、1道程序设计题和1道综合应用题。这里准备记录分享一下我的思路和解法。        我毫不犹豫地选择先完成后面4道程序题目，如果在难度中上等的情况下，很显然，这段时间感觉是比较紧迫的。另外，我们知道编程需要充足的时间去思考分析问题，打好程序代码后还
stm32 应用实例—— USART 串口通讯
CNLWW的博客
12-05 1113
stm32 应用实例—— USART 串口通讯1.基于寄存器、固件库编程的差异性2. 完成STM32的USART窗口通讯程序3.总结 1.基于寄存器、固件库编程的差异性 从应用角度讲，寄存器相对来说是属于更底层的，类似于驱动层，而固件库则类似通过将寄存器封装之后的应用层。相比之下，固件库更像是包装好给用户的产品一样，只需要我们使用就行了，让封装自己和寄存器打交道，而使用寄存器在使用时必须要清楚自己要操作那个一个寄存器，就很复杂，需要了解清楚寄存器的底层配置。 从专业角度来讲，由于寄存器更底层，更需要用户了解
STM32串口通讯—— USART通信实践
MMiL258的博客
01-15 522
1
[Alg]排序算法之交换排序
屎壳郎的博客
08-02 268
[Alg]排序算法之交换排序 （写文章要有深度，直接刨它祖坟）# 作者：屎壳郎 miaosg01@163.com 日期：July 2021 版次：初版 简介： 交换排序是排序算法中的一大类，通过构成反序数据对的两两交换来消除反序，最终得到有秩序的排列。那么排列交换的本质是什么呢？说来话长，让我们回到远古时代，重温数据结构，从环形链表开始说起。 0、 交换排序的本质 环形链表的合并： 假设现在我们有两个指针分别指向两个环形链表，要想把两个环形链表合并成一个的操作为：LINK(ptr1)↔LINK(ptr2
经典永不过时！重温设计模式
C语言与CPP编程的博客
04-11 955
| 导语在软工程中，设计模式（design pattern）是对软件设计中普遍存在（反复出现）的各种问题，所提出的解决方案。这个术语是由埃里希·伽玛（Erich Gamma）等人在199...
Ubuntu、stm32重温全局变量、局部变量、堆、栈
zxp_124的博客
12-23 1017
一、 1、堆 、栈 STM32中的堆栈 单片机是一种集成电路芯片，集成CPU、RAM、ROM、多种I/O口和中断系统、定时器/计数器等功能。CPU中包括了各种总线电路，计算电路，逻辑电路，还有各种寄存器。 stm32 有通用寄存器 R0‐ R15 以及一些特殊功能寄存器，其中包括了堆栈指针寄存器。 当stm32正常运行程序的时候，来了一个中断，CPU就需要将寄存器中的值压栈到RAM里，然后将数据所在的地址存放在堆栈寄存器中。 等中断处理完成退出时，再将数据出栈到之前的寄存器中，这个在C语言里是自动.
Pandas_数据结构详解
2201_75415080的博客
09-19 1218
DataFrame是一个表格型的==结构化==数据结构，它含有一组或多组有序的列（Series），每列可以是不同的值类型（数值、字符串、布尔值等）。DataFrame是Pandas中最基本的数据结构，Series的许多属性和方法在DataFrame中也一样适用.两个Series之间计算时，索引值相同的元素之间会进行计算；索引值不同的元素的计算结果会用NaN值(缺失值)填充。两个Series之间计算时，索引值相同的元素之间会进行计算；索引值不同的元素的计算结果会用NaN值(缺失值)填充。
数据结构：二叉树（一）
2303_78940834的博客
09-21 749
ps：偷懒了几天，接着更新。
数据结构——二叉树堆的专题
imaima666的博客
09-19 795
如果有一个关键码的集合K = {K0 ，K1 ，K2 ，K3…) i = 0，1， 2…，则称为(或将。
数据结构—树
最新发布
2301_80151359的博客
09-22 430
在文件系统中，树结构被广泛应用，它通过父结点和子结点之间的关系来表示不同层级的文件和文件夹之间的关联。树结构相对线性表就比较复杂了，要存储表示起来就比较麻烦了，既然保存值域，也要保存结点和结点之间的关系。若一个结点含有子结点，则这个结点称为其子结点的父结点；如上图：A是B的父结点。以某结点为根的子树中任一结点都称为该结点的子孙。如上图：所有结点都是A的子孙。一个结点含有的子树的根结点称为该结点的子结点；1.有一个特殊的结点，称为根结点，根结点没有前驱结点。具有相同父结点的结点互称为兄弟结点(亲兄弟)；
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值