C语言通用双向链表

已于 2023-01-29 15:14:04 修改
阅读量266 收藏 3
点赞数 2
分类专栏： C语言 文章标签： 链表 c语言 数据结构
于 2023-01-29 14:54:02 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_48995611/article/details/128788470
版权

本文提供一种C语言双向链表的通用接口，且均使用宏描述，故仅需包含头文件。该接口在实际应用中使用更方便、灵活。

一、基本结构在这里插入图片描述

BASE结点：即链表的结构体，主要记录链表的 第一个（start） 和 最后一个（end） 结点指针。
结点n：用户定义的结构体，除了数据外还需要包含 指针域（link），用于双向链表的连接。

二、结点定义方法

1. BASE结点

#define LIST_BASE_NODE_T(TYPE)\
struct\
{\
    unsigned int    count;\
    TYPE*           start;\
    TYPE*           end;\
}

count为该链表的结点总数，实际应用场景经常会用到。

2. 结点指针域

#define LIST_NODE_T(TYPE)\
struct\
{\
    TYPE*           prev;\
    TYPE*           next;\
}

示例

此刻有结构体 test_node_t：

typedef struct test_node_struct test_node_t;
struct test_node_struct
{
    int         value;
};

仅需要为其添加指针域，以及链表的定义，以便使用后面封装的接口。

typedef struct test_node_struct test_node_t;
struct test_node_struct
{
    int         value;
    LIST_NODE_T(test_node_t) link;
};
typedef LIST_BASE_NODE_T(test_node_t) test_list_t;

注：可以添加多个指针域link1、link2…以便该结点可以同时存在于多个链表中。

三、基本操作接口

1. ADD FIRST

/* 添加结点N到链表的第一个 */
#define LIST_ADD_FIRST(LINK, BASE, N)\
do\
{\
    (BASE).count++;\
    /* 初始化指针域 */\
    (N)->LINK.prev = NULL;\
    (N)->LINK.next = (BASE).start;\
    /* 如果start存在, 设置N为它的prev */\
    if ((BASE).start)\
    {\
        (BASE).start->LINK.prev = (N);\
    }\
    /* 如果start不存在, 要设置N为end, 最后设置N为start */\
    else\
    {\
        (BASE).end = (N);\
    }\
    (BASE).start = (N);\
} while (0)

2. ADD LAST

/* 添加结点N到链表的最后一个 */
#define LIST_ADD_LAST(LINK, BASE, N)\
do\
{\
    (BASE).count++;\
    /* 初始化指针域 */\
    (N)->LINK.prev = (BASE).end;\
    (N)->LINK.next = NULL;\
    /* 如果end存在, 设置N为它的next */\
    if ((BASE).end)\
    {\
        (BASE).end->LINK.next = (N);\
    }\
    /* 如果end不存在, 要设置N为start, 最后设置N为end */\
    else\
    {\
        (BASE).start = (N);\
    }\
    (BASE).end = (N);\
} while (0)

3. INSERT BEFORE

/* 插入结点N到结点NODE的前面 */
#define LIST_INSERT_BEFORE(LINK, BASE, NODE, N)\
do\
{\
    (BASE).count++;\
    /* 初始化指针域 */\
    (N)->LINK.prev = (NODE)->LINK.prev;\
    (N)->LINK.next = (NODE);\
    /* 如果NODE的prev存在, 设置N为它的next */\
    if ((NODE)->LINK.prev)\
    {\
        (NODE)->LINK.prev->LINK.next = (N);\
    }\
    /* 如果NODE的prev不存在, 要设置N为start, 最后设置N为NODE的prev */\
    else\
    {\
        (BASE).start = (N);\
    }\
    (NODE)->LINK.prev = (N);\
} while (0)

4. INSERT AFTER

/* 插入N到结点NODE的后面 */
#define LIST_INSERT_AFTER(LINK, BASE, NODE, N)\
do\
{\
    (BASE).count++;\
    /* 初始化指针域 */\
    (N)->LINK.prev = (NODE);\
    (N)->LINK.next = (NODE)->LINK.next;\
    /* 如果NODE的next存在, 设置N为它的prev */\
    if ((NODE)->LINK.next)\
    {\
        (NODE)->LINK.next->LINK.prev = (N);\
    }\
    /* 如果NODE的next不存在, 要设置N为end, 最后设置N为NODE的next */\
    else\
    {\
        (BASE).end = (N);\
    }\
    (NODE)->LINK.next = (N);\
} while (0)

5. REMOVE

/* 从链表中移除结点 */
#define LIST_REMOVE(LINK, BASE, N)\
do\
{\
    (BASE).count--;\
    /* 如果N的prev存在, 设置N的next为它的next */\
    if ((N)->LINK.prev)\
    {\
        (N)->LINK.prev->LINK.next = (N)->LINK.next;\
    }\
    /* 如果N的prev不存在, 设置N的next为start */\
    else\
    {\
        (BASE).start = (N)->LINK.next;\
    }\
    /* 如果N的next存在, 设置N的prev为它的prev */\
    if (((N)->LINK).next)\
    {\
        (N)->LINK.next->LINK.prev = (N)->LINK.prev;\
    }\
    /* 如果N的next不存在, 设置N的prev为end */\
    else\
    {\
        (BASE).end = (N)->LINK.prev;\
    }\
    /* 最后清空指针域 */\
    (N)->LINK.prev = NULL;\
    (N)->LINK.next = NULL;\
} while (0)

四、其他接口

/* 获取链表长度 */
#define LIST_GET_LEN(BASE)      ((BASE).count)

/* 获取链表第一个结点 */
#define LIST_GET_FIRST(BASE)    ((BASE).start)

/* 获取链表最后一个结点 */
#define LIST_GET_LAST(BASE)     ((BASE).end)

/* 获取N的上一个结点 */
#define LIST_GET_PREV(LINK, N)  ((N)->LINK.prev)

/* 获取N的下一个结点 */
#define LIST_GET_NEXT(LINK, N)  ((N)->LINK.next)

/* 从头开始向后查找结点 */
#define LIST_SEARCH_FROM_FIRST(LINK, BASE, N, TEST)\
do\
{\
    (N) = LIST_GET_FIRST(BASE);\
    while (N)\
    {\
        if (TEST)\
            break;\
        (N) = LIST_GET_NEXT(LINK, N);\
    }\
} while (0)

/* 从末尾开始向前查找结点 */
#define LIST_SEARCH_FROM_LAST(LINK, BASE, N, TEST)\
do\
{\
    (N) = LIST_GET_LAST(BASE);\
    while (N)\
    {\
        if (TEST)\
            break;\
        (N) = LIST_GET_PREV(LINK, N);\
    }\
} while (0)

/* 从结点NODE开始向前查找结点 */
#define LIST_SEARCH_BEFORE_NODE(LINK, BASE, NODE, N, TEST)\
do\
{\
    (N) = (NODE);\
    while (N)\
    {\
        if (TEST)\
            break;\
        (N) = LIST_GET_PREV(LINK, N);\
    }\
} while (0)

/* 从结点NODE开始向后查找结点 */
#define LIST_SEARCH_AFTER_NODE(LINK, BASE, NODE, N, TEST)\
do\
{\
    (N) = (NODE);\
    while (N)\
    {\
        if (TEST)\
            break;\
        (N) = LIST_GET_NEXT(LINK, N);\
    }\
} while (0)

测例

#include "list.h"
#include <assert.h>

typedef struct node_struct node_t;
struct node_struct
{
    int         value;
    LIST_NODE_T(node_t) link1;
    LIST_NODE_T(node_t) link2;
};
typedef LIST_BASE_NODE_T(node_t) list_t;

void test_list()
{
    const int       num = 1000;
    int             i;
    node_t*         n;
    node_t*         n1;
    node_t*         n2;
    node_t*         n_prev;
    node_t*         n_next;
    node_t*         n249;
    node_t*         n499;
    node_t*         n500;
    node_t*         n750;
    list_t          L1 = { 0 }, L2 = { 0 };

    /* 申请, 按顺序添加到L1 */
    for (i = 0; i < num; i++)
    {
        n = malloc(sizeof(node_t));
        assertx(n);
        n->value = i;
        LIST_ADD_LAST(link1, L1, n);
    }

    /* 向后遍历L1, 找到结点249 */
    LIST_SEARCH_FROM_FIRST(link1, L1, n249, n249->value == 249);
    /* 向前遍历L1, 找到结点750 */
    LIST_SEARCH_FROM_LAST(link1, L1, n750, n750->value == 750);
    /* 从结点249向后遍历L1, 找到结点499 */
    LIST_SEARCH_AFTER_NODE(link1, L1, n249, n499, n499->value == 499);
    /* 从结点750向前遍历L1, 找到结点500 */
    LIST_SEARCH_BEFORE_NODE(link1, L1, n750, n500, n500->value == 500);
    assert(n499 && n500 && LIST_GET_NEXT(link1, n499) == n500 && LIST_GET_PREV(link1, n500) == n499);

    /* 从结点249往前, 逐个添加到L2开始(0-249) */
    n = n249;
    while (n)
    {
        LIST_ADD_FIRST(link2, L2, n);
        n = LIST_GET_PREV(link1, n);
    }
    /* 从结点750往后, 逐个添加到L2最后(750-999) */
    n = n750;
    while (n)
    {
        LIST_ADD_LAST(link2, L2, n);
        n = LIST_GET_NEXT(link1, n);
    }
    /* 从结点250开始, 直到结点499, 逐个插入到L2(250-499) */
    n = n249;
    do
    {
        n_prev = n;
        n = LIST_GET_NEXT(link1, n);
        LIST_INSERT_AFTER(link2, L2, n_prev, n);
    } while (n != n499);
    /* 从结点749开始, 直到结点500, 逐个插入到L2(500-749) */
    n = n750;
    do
    {
        n_next = n;
        n = LIST_GET_PREV(link1, n);
        LIST_INSERT_BEFORE(link2, L2, n_next, n);
    } while (n != n500);

    assert(LIST_GET_LEN(L1) == num && LIST_GET_LEN(L2) == num);
    /* 验证L1和L2中结点顺序是否一致 */
    n1 = LIST_GET_FIRST(L1);
    n2 = LIST_GET_FIRST(L2);
    while (n1 && n2)
    {
        assertx(n1->value == n2->value);
        n1 = LIST_GET_NEXT(link1, n1);
        n2 = LIST_GET_NEXT(link2, n2);
    }

    /* 从L1中移除所有结点 */
    n = LIST_GET_FIRST(L1);
    while (n)
    {
        LIST_REMOVE(link1, L1, n);
        n = LIST_GET_FIRST(L1);
    }
    /* 释放 */
    n = LIST_GET_LAST(L2);
    while (n)
    {
        LIST_REMOVE(link2, L2, n);
        free(n);
        n = LIST_GET_LAST(L2);
    }
    return;
}

源码（list.h）

/**************************************************************
文件:
    list.h
目的:
    提供双向链表的方法和接口
接口:
    LIST_BASE_NODE_T            定义链表类型
    LIST_NODE_T                 定义链表结点的指针域

    LIST_INIT                   链表初始化
    LIST_NODE_INIT              结点初始化

    LIST_ADD_FIRST              添加到链表的第一个
    LIST_ADD_LAST               添加到链表的最后一个
    LIST_INSERT_BEFORE          插入到结点之前
    LIST_INSERT_AFTER           插入到结点之后
    LIST_REMOVE                 从链表中移除结点

    LIST_GET_LEN                获取链表长度
    LIST_GET_FIRST              获取链表第一个结点
    LIST_GET_LAST               获取链表最后一个结点
    LIST_GET_PREV               获取上一个结点
    LIST_GET_NEXT               获取下一个结点

    LIST_SEARCH_FROM_FIRST      从头开始向后查找结点
    LIST_SEARCH_FROM_LAST       从末尾开始向前查找结点
    LIST_SEARCH_BEFORE_NODE     从结点NODE开始向前查找结点
    LIST_SEARCH_AFTER_NODE      从结点NODE开始向后查找结点
**************************************************************/
#ifndef LIST_H
#define LIST_H

/* 说明: 用于定义链表类型 */
#define LIST_BASE_NODE_T(TYPE)\
struct\
{\
    unsigned int    count;\
    TYPE*           start;\
    TYPE*           end;\
}

/* 说明: 用于定义指针域 */
#define LIST_NODE_T(TYPE)\
struct\
{\
    TYPE*           prev;\
    TYPE*           next;\
}

/* 初始化链表 */
#define LIST_INIT(BASE)\
do\
{\
    (BASE).count = 0;\
    (BASE).start = NULL;\
    (BASE).end   = NULL;\
} while (0)

/* 初始化结点的指针域 */
#define LIST_NODE_INIT(LINK, N)\
do\
{\
    (N)->LINK.prev = NULL;\
    (N)->LINK.next = NULL;\
} while (0)

/* 添加结点N到链表的第一个 */
#define LIST_ADD_FIRST(LINK, BASE, N)\
do\
{\
    (BASE).count++;\
    /* 初始化指针域 */\
    (N)->LINK.prev = NULL;\
    (N)->LINK.next = (BASE).start;\
    /* 如果start存在, 设置N为它的prev */\
    if ((BASE).start)\
    {\
        (BASE).start->LINK.prev = (N);\
    }\
    /* 如果start不存在, 要设置N为end, 最后设置N为start */\
    else\
    {\
        (BASE).end = (N);\
    }\
    (BASE).start = (N);\
} while (0)

/* 添加结点N到链表的最后一个 */
#define LIST_ADD_LAST(LINK, BASE, N)\
do\
{\
    (BASE).count++;\
    /* 初始化指针域 */\
    (N)->LINK.prev = (BASE).end;\
    (N)->LINK.next = NULL;\
    /* 如果end存在, 设置N为它的next */\
    if ((BASE).end)\
    {\
        (BASE).end->LINK.next = (N);\
    }\
    /* 如果end不存在, 要设置N为start, 最后设置N为end */\
    else\
    {\
        (BASE).start = (N);\
    }\
    (BASE).end = (N);\
} while (0)

/* 插入结点N到结点NODE的前面 */
#define LIST_INSERT_BEFORE(LINK, BASE, NODE, N)\
do\
{\
    (BASE).count++;\
    /* 初始化指针域 */\
    (N)->LINK.prev = (NODE)->LINK.prev;\
    (N)->LINK.next = (NODE);\
    /* 如果NODE的prev存在, 设置N为它的next */\
    if ((NODE)->LINK.prev)\
    {\
        (NODE)->LINK.prev->LINK.next = (N);\
    }\
    /* 如果NODE的prev不存在, 要设置N为start, 最后设置N为NODE的prev */\
    else\
    {\
        (BASE).start = (N);\
    }\
    (NODE)->LINK.prev = (N);\
} while (0)

/* 插入N到结点NODE的后面 */
#define LIST_INSERT_AFTER(LINK, BASE, NODE, N)\
do\
{\
    (BASE).count++;\
    /* 初始化指针域 */\
    (N)->LINK.prev = (NODE);\
    (N)->LINK.next = (NODE)->LINK.next;\
    /* 如果NODE的next存在, 设置N为它的prev */\
    if ((NODE)->LINK.next)\
    {\
        (NODE)->LINK.next->LINK.prev = (N);\
    }\
    /* 如果NODE的next不存在, 要设置N为end, 最后设置N为NODE的next */\
    else\
    {\
        (BASE).end = (N);\
    }\
    (NODE)->LINK.next = (N);\
} while (0)

/* 从链表中移除结点 */
#define LIST_REMOVE(LINK, BASE, N)\
do\
{\
    (BASE).count--;\
    /* 如果N的prev存在, 设置N的next为它的next */\
    if ((N)->LINK.prev)\
    {\
        (N)->LINK.prev->LINK.next = (N)->LINK.next;\
    }\
    /* 如果N的prev不存在, 设置N的next为start */\
    else\
    {\
        (BASE).start = (N)->LINK.next;\
    }\
    /* 如果N的next存在, 设置N的prev为它的prev */\
    if (((N)->LINK).next)\
    {\
        (N)->LINK.next->LINK.prev = (N)->LINK.prev;\
    }\
    /* 如果N的next不存在, 设置N的prev为end */\
    else\
    {\
        (BASE).end = (N)->LINK.prev;\
    }\
    /* 最后清空指针域 */\
    (N)->LINK.prev = NULL;\
    (N)->LINK.next = NULL;\
} while (0)

/* 获取链表长度 */
#define LIST_GET_LEN(BASE)      ((BASE).count)

/* 获取链表第一个结点 */
#define LIST_GET_FIRST(BASE)    ((BASE).start)

/* 获取链表最后一个结点 */
#define LIST_GET_LAST(BASE)     ((BASE).end)

/* 获取N的上一个结点 */
#define LIST_GET_PREV(LINK, N)  ((N)->LINK.prev)

/* 获取N的下一个结点 */
#define LIST_GET_NEXT(LINK, N)  ((N)->LINK.next)

/* 从头开始向后查找结点 */
#define LIST_SEARCH_FROM_FIRST(LINK, BASE, N, TEST)\
do\
{\
    (N) = LIST_GET_FIRST(BASE);\
    while (N)\
    {\
        if (TEST)\
            break;\
        (N) = LIST_GET_NEXT(LINK, N);\
    }\
} while (0)

/* 从末尾开始向前查找结点 */
#define LIST_SEARCH_FROM_LAST(LINK, BASE, N, TEST)\
do\
{\
    (N) = LIST_GET_LAST(BASE);\
    while (N)\
    {\
        if (TEST)\
            break;\
        (N) = LIST_GET_PREV(LINK, N);\
    }\
} while (0)

/* 从结点NODE开始向前查找结点 */
#define LIST_SEARCH_BEFORE_NODE(LINK, BASE, NODE, N, TEST)\
do\
{\
    (N) = (NODE);\
    while (N)\
    {\
        if (TEST)\
            break;\
        (N) = LIST_GET_PREV(LINK, N);\
    }\
} while (0)

/* 从结点NODE开始向后查找结点 */
#define LIST_SEARCH_AFTER_NODE(LINK, BASE, NODE, N, TEST)\
do\
{\
    (N) = (NODE);\
    while (N)\
    {\
        if (TEST)\
            break;\
        (N) = LIST_GET_NEXT(LINK, N);\
    }\
} while (0)

#endif
江小辉9914
关注
  • 2
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
C语言---双向链表（详解）---数据结构
weixin_57535054的博客
02-07 6535
双向链表所需要头文件 首先重定义类型名 意义我前几篇讲过几次了，这里就不在赘述了，（顺序表，单链表的开头都有说明） 然后我们需要一个结构体 结构体包含 ： 存储数据的 a 指向一个节点的指针 next 指向上一个节点的指针 prve 双向链表实现的函数功能有 ：1.申请动态内存空间 2.初始化 3.双向链表的头，尾的插入与删除，在合法的任意位置进行插入和删除 4.释放链表，5.打印链表 1.申请动态内存空间 因为进行插入和初始化需要用到此函数 所以我们要先实现此功能 1.先申.
如何实现C语言通用链表
duapple的博客
07-04 1158
C语言通用链表实现 C语言的数组有时候很好用，但在不知道数据有多少的时候，并且涉及到某个数据的删除时，操作起来很不方便，这个时候就需要用到链表。自己定义一个链表数据结构，然后实现它，此时这个链表仅能表示你要处理的相关数据，并不是通用的，这将导致你要使用的时候就得重新写数据结构的代码。这个时候，定义一个通用链表，用这个链表就能处理所有的数据类型了，因为是通用的，所以会有一部分代码需要在用户使用的时候自己完成。 常见链表定义 struct Student { char name[20]; int
数据结构—C语言实现双向链表
最新发布
Mike的博客
05-01 1098
双向带头循环链表
通用数据类型链表C语言实现
qq_33471732的博客
03-10 410
该代码首先初始化了一个空的链表，然后向其添加了一个整型、一个浮点型和一个字符型数据。随后遍历了链表并打印了每个节点的数据。之后，删除了头节点并重新遍历了链表，打印出了剩余节点的数据。通用链表是一种动态内存分配的数据结构，其中每个节点包含一个指向下一个节点的指针和一个指向任意类型数据的指针。因此，通用链表可以容纳任意类型的数据，这是其与其他数据结构不同的地方。其中，head指向链表头，tail指向链表尾，size为链表节点数。其中，data指向任意类型的数据，next指向下一个节点。
c语言简单实现双向链表
欢迎来到梨+萍的博客，不准备看点啥学习嘛。。。
08-18 2613
c语言最简单实现双向链表
双向链表--C语言实现数据结构
2201_76062618的博客
05-13 4939
本文详细介绍带头双向循环链表，内容较为丰富
C语言实现通用双向链表标准版.rar
08-12
本资源“C语言实现通用双向链表标准版.rar”提供了一个使用C语言实现的通用双向链表实例，这对于理解和掌握数据结构，尤其是链表操作具有重要意义。 双向链表是一种线性数据结构，与单向链表不同，它允许节点在两个...
通用双向链表以及内存检漏算法
05-01
本项目涉及的是“通用双向链表”和“内存检漏算法”，这两个主题都是C语言编程中不可或缺的部分。 首先，我们来看通用双向链表。双向链表是一种线性数据结构，每个节点包含数据部分和两个指针，一个指向前一个节点...
C语言的双链表
04-01
内核链表是一种双向循环链表，内核链表的节点节点结构中只有指针域 使用内核链表的时候，将内核链表作为一个成员放入到一个结构体中使用 我们在链表中找到内核链表结构的地址，通过这个地址就可以找到外部大结构体...
从vxWorks源码中提取，一种通用化双向链表设计，亲测可用
04-26
本主题聚焦于一种通用化的双向链表设计，这种设计来源于vxWorks操作系统的核心代码，对于理解和实现嵌入式系统中的数据管理具有重要意义。 双向链表与单链表相比，具有更灵活的操作特性，因为它允许从两个方向遍历...
Java语言中链表和双向链表
01-08
C语言和C＋＋语言中是用指针来实现链表结构的，由于Java语言不提供指针，所以有人认为在Java语言中不能实现链表，其实不然，Java语言比C和C＋＋更容易实现链表结构。Java语言中的对象引用实际上是一个指针（本文中的...
c语言 链表 双向链表 双向循环链表
02-26
从linux内核移植出来，独立于用户数据结构，里面有实例参考。C语言代码。
C语言实现双向链表
09-03
本文给大家分享的是一段使用C语言实现双向链表的代码，完全是根据自己的理解和认识来编写的，希望大家能够喜欢，文章的最后附上了一个网友写的对于双向链表删除节点、插入节点、双向输出等操作的代码，也非常不错，推荐给大家
Linux内核中的通用双向循环链表
01-09
开发中接触Linux越来越多，休息放松之余，免不了翻看翻看神秘的Linux的内核。看到双向链表时，觉得挺有意思的，此文记下。 　　作为众多基础数据结构中的一员，双向循环链表在各种“教科书”中的实现是相当的标准和一致的。 　　大概是下面这个样子： 　　1 typedef struct node_tag{ 　　2     //T data; 　　3     struct node_tag *prev; 　　4     struct node_tag *next; 　　5 }node; 　　当你需要某种类型的链表时，把数据成员之类的往节点里塞是了。比如菜谱链表，里面可以有宫爆鸡丁，酸
C语言数据结构之双向链表
Qurry的博客
09-21 1268
前面介绍了单链表，由于单链表遍历查找是单向性的，故引出了双向链表的概念，也叫双链表，既可以向前查找，也可以向后遍历。
C语言实现链表之单向链表（七）尾结点后插入结点
君临天下的博客
11-08 3956
C语言实现链表之单向链表（七）尾结点后插入结点     上一篇文章给出了删除头结点的函数，本篇文章将给出在尾结点后插入结点的函数。 /*============================================================================== * 操作 ：在尾结点之后加入一个新结点 * 操作前：pHeadNode为链
双向链表的基本操作及C语言代码实现
weixin_51884452的博客
03-28 331
双向链表的基本操作及c语言代码实现
链表(list)的宏定义实现
yoyo的专栏
01-18 6331
-- 看代码是一种享受 　　最近在看DHCP的源码，一些好的记录下来。平时写C，用到链表就是copy数据结构上的代码，简单粗暴，今天换种方式，看下宏定义实现的链表，好处自然是代码少、效率高。 　　首先下面链表宏定义的实现，摘自wide-dhcpv6-20080615源码包/* * List declarations. */#define LIST_HEAD(name,
C语言实现双向链表的算法(含完整源码)
CyberNova的博客
08-25 84
双向链表是一种比较常见的数据结构，它可以在单向链表的基础上增加了一个指向前驱节点的指针，这样既可以从头部开始遍历，也可以从尾部开始遍历，并且插入或删除操作也方便了很多，下面将介绍C语言实现双向链表的详细算法和源代码。该函数用于在指定位置插入新节点，需要传入链表头指针、插入位置和新节点数据。该函数用于删除指定位置的节点，需要传入链表头指针和删除位置。该函数用于遍历链表并打印节点数据，需要传入链表头指针。该函数用于初始化链表，需要传入链表头指针。是指向前驱节点的指针，是指向后继节点的指针。表示节点存储的数据，
使用C语言实现双向链表的全部功能
04-05
以下是使用C语言实现双向链表的全部功能的代码： ```c #include #include // 定义双向链表的节点结构体 typedef struct Node { int data; struct Node* prev; struct Node* next; } Node; // 初始化双向链表...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值