实现一个自己的双向链表

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

目录

问题引入

  • C 在写很多东西的时候都会牵扯到一些基础的数据结构的使用，而双向链表可以封装成好几种常用的数据结构，所以想着自己实现一个自己的双向链表，也会在以后慢慢完善此代码。

接口设计

/*
初始化双向链表
return value ：
	0 : 成功
	-1 ： malloc() 分配内存时出现错误
*/
int llist_init(d_llist_t **llist);

/*
往 llist 链表中插入值 *key，compare 为回调比较大小的函数，用户自己实现
这里设定 key 为堆上的内存地址，在 llist_destroy() 中会 free() 保证内存不会泄露
return value：
	0 ： 成功
	-1 ： malloc() 分配内存时出错
*/
typedef int (*compare)(void *a, void *b);
/*
compare return value:
        1 : a > b
        -1 : a < b
        0 : a == b
*/
int llist_insert(d_llist_t *llist, void *key, compare cmp);

/*
拿出链表对应位置的节点的 key，会从链表中删除节点
返回值为 key 本身，原节点已从链表中删除并 free，使用完后记得 free(key)
return value：
	NULL : 链表为空
	非空 : 对应位置的 key
*/
d_llist_node_t *llist_pop_first(d_llist_t *llist);
d_llist_node_t *llist_pop_last(d_llist_t *llist);

/*
查看链表对应位置的节点的 key，但不从链表中删除节点
return value ：
	NULL : 链表为空
	非空 ： key
*/
d_llist_node_t *llist_head_look(d_llist_t *llist);
d_llist_node_t *llist_tail_look(d_llist_t *llist);

/*
销毁链表
return value：
	0 ： 成功
	其他情况 ： 未知错误
*/
int llist_destroy(d_llist_t *llist);

/*
链表的遍历，针对 key 的输出格式，给出了回调接口
return value：
	0 ： 成功
	其他情况 ： 未知错误
*/
typedef int (*traver)(void *node);
int llist_traver(d_llist_t *llist, traver tvr);

/*
检查链表是否为用户指定的有序链表
return value：
	0 ： 有序
	-1 ： 不是有序的
*/
// typedef int (*compare)(void *a, void *b);
int llist_check(d_llist_t *llist, compare cmp);

代码

double_llist.h

#ifndef DOUBLE_LLIST__
#define DOUBLE_LLIST__

typedef void d_llist_node_t;
typedef void d_llist_t;

int llist_init(d_llist_t **llist);

typedef int (*compare)(void *a, void *b);
int llist_insert(d_llist_t *llist, void *key, compare cmp);

d_llist_node_t *llist_pop_first(d_llist_t *llist);
d_llist_node_t *llist_pop_last(d_llist_t *llist);

d_llist_node_t *llist_head_look(d_llist_t *llist);
d_llist_node_t *llist_tail_look(d_llist_t *llist);

int llist_destroy(d_llist_t *llist);

typedef int (*traver)(void *node);
int llist_traver(d_llist_t *llist, traver tvr);

// typedef int (*compare)(void *a, void *b);
int llist_check(d_llist_t *llist, compare cmp);


#endif

double_llist.c

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

#include "./double_llist.h"


typedef struct llist_node_s{

    void *key;	// key 指向用户传进来的数据的堆内存地址
    struct llist_node_s *prev;
    struct llist_node_s *next;

}llist_node_t;

typedef struct llist_s{
	// 这块也可以根据实际情况加一些其他元素
	
    llist_node_t *head;	// 链表的头节点
    llist_node_t *tail;	// 链表的尾节点

}llist_t;


int llist_init(void **llist){

    llist_t *me = NULL;

    me = (llist_t*)malloc(sizeof(*me));
    if(me == NULL){
        return -1;
    }

    me->head = NULL;
    me->tail = NULL;

    *llist = me;

    return 0;
}

/*
    typedef int (*compare)(void *a, void *b);
    compare return value:
        1 : a > b
        -1 : a < b
        0 : a == b
*/
int llist_insert(d_llist_t *llist, void *key, compare cmp){

    llist_t *me = llist;
    llist_node_t *cur = me->head;
    llist_node_t *node_ = NULL;

    node_ = (llist_node_t*)malloc(sizeof(*node_));
    if(node_ == NULL){
        return -1;
    }
    node_->next = NULL;
    node_->prev = NULL;
    node_->key = key;

    int res = 0;

    while(cur != NULL){

        res = cmp(key, cur->key);
        if(res > 0){
            cur = cur->next;
        }else{  // res < 0 || res == 0
            break;
        }

    }


    if(cur == NULL){
        // insert on tail
        // or head = tail = NULL, llist is null
        node_->prev = me->tail;
        node_->next = NULL;
        if(me->tail != NULL){
            me->tail->next = node_;
            me->tail = node_;
        }else{
            me->tail = node_;
        }
        if(me->head == NULL){
            me->head = node_;
        }

    }else if(cur == me->head){
        // insert on head
        node_->next = me->head;
        node_->prev = NULL;
        me->head->prev = node_;
        me->head = node_;

    }else{

        node_->next = cur;
        node_->prev = cur->prev;
        cur->prev->next = node_;
        cur->prev = node_;

    }

    return 0;
}

void *llist_pop_first(void *llist){

    llist_t *me = llist;
    llist_node_t *cur = me->head;

    if(cur == NULL){

        return NULL;

    }else if(cur->next == NULL){

        me->head = NULL;
        me->tail = NULL;

    }else{

        me->head = cur->next;
        me->head->prev = NULL;

    }

    void *ret = cur->key;

    free(cur);

    return ret;
}

void *llist_pop_last(void *llist){

    llist_t *me = llist;
    llist_node_t *cur = me->tail;

    if(cur == NULL){
        return NULL;
    }else if(cur->prev == NULL){
        me->head = NULL;
        me->tail = NULL;
    }else{
        me->tail = cur->prev;
        me->tail->next = NULL;
    }


    void *ret = cur->key;

    free(cur);

    return ret;
}

int llist_destroy(void *llist){

    llist_t *me = llist;
    llist_node_t *cur = me->head, *temp = NULL;

    while(cur != NULL){

        temp = cur->next;

        free(cur->key);
        free(cur);

        cur = temp;

    }

    free(me);

    llist = NULL;

    return 0;
}

/*
typedef int (*traver)(void *node);
*/
int llist_traver(void *llist, traver tvr){

    llist_t *me = llist;
    llist_node_t *cur = me->head;

    while(cur != NULL){

        tvr(cur->key);

        cur = cur->next;
        if(cur){
            printf(" -> ");
        }
    }
    printf("\n");

    return 0;
}


int llist_check(void *llist, compare cmp){

    llist_t *me = llist;
    llist_node_t *cur = me->head;

    if(cur != NULL && cur->next != NULL){
        cur = cur->next;
    }else{
        return 0;
    }

    while(cur != NULL){

        if(cmp(cur->key, cur->prev->key) < 0){
            return -1;
        }
        cur = cur->next;

    }

    return 0;
}




d_llist_node_t *llist_head_look(d_llist_t *llist){

    llist_t *me = llist;

    if(me->head == NULL){
        return NULL;
    }

    return me->head->key;
}
d_llist_node_t *llist_tail_look(d_llist_t *llist){

    llist_t *me = llist;

    if(me->tail == NULL){
        return NULL;
    }

    return me->tail->key;
}

测试代码 test.c

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

#include "./double_llist.h"


// 用户根据自己的数据类型实现的比较函数
int mycompare(void *a, void *b){
    int *x = a;
    int *y = b;

    return (*x) - (*y);
}

// 自定义输出函数
int mytraver(void *key){

    int *x = key;

    printf("[%d]", *x);
    
    return 0;
}

int main(){

    d_llist_t *llist = NULL;
    int ret = 0;
	
	// init 链表
    ret = llist_init(&llist);
    if(ret){
        puts("init()");
        exit(1);
    }

    srand((unsigned)time(NULL));
    int i = 0;
    for(i = 0; i < 1024 * 16; i++){
		
		// 链表中添加的元素需要开辟在堆上
        int *key = (int*)malloc(sizeof(int));

        (*key) = (rand() % 1024 + 1);
        // 添加元素
        // 若不需要指定排序,还可以指定头插还是尾插,这个以后再实现
        ret = llist_insert(llist, key, mycompare);

		// 测试 取出数据
        if(i % 2){
            llist_pop_last(llist);
            // llist_pop_first(llist);
        }

    }
		
	// 遍历链表
    // llist_traver(llist, mytraver);

	// 检查链表是否有序
    ret = llist_check(llist, mycompare);
    if(ret){
        printf("error\n");
    }else{
        printf("ok\n");
    }

	// 查看链表第一个节点的 key
    int *data = llist_head_look(llist);
    if(data != NULL){
        mytraver(data);
    }else{
        printf("llist is empty\n");
    }

    data = NULL;
	// 查看链表最后一个节点的 key
    data = llist_tail_look(llist);
    if(data != NULL){
        mytraver(data);
    }else{
        printf("llist is empty\n");
    }

	// 用完销毁链表,因为其中有开辟在堆上的内存,不删除会导致内存泄漏
	// 添加元素时开辟在堆上的 key 也会在这里 free
    ret = llist_destroy(llist);
    if(ret){
        puts("destroy()");
        exit(1);
    }

    exit(0);
}

总结

功能列表

  1. 数据都是用户自己定义
  2. 链表的有序 / 无序插入,如何排序可以由用户自己控制
  3. 链表的首尾取出 / 查看
  4. 检测链表是否有序
  5. 链表的遍历, 打印格式也可以由用户自己设计,同时也可以打成日志

待添加功能

  1. 搜索查看 / 取出指定节点的 key;
  2. 可以在链表的结构体中添加一些额外的变量,用来记录链表中元素个数等等情况;\
  3. 更多的添加节点的方式,如头插法和尾插法;
  4. 等哪天用到的时候再总结.
remoter.
关注
专栏目录
双向链表实现
hxy1625309592的博客
12-15 2149
1.1 基本介绍 1、单向链表优缺点 单向链表，查找的方向只能是一个方向，而双向链表可以向前或者向后查找。 单向链表不能自我删除，需要靠辅助节点 ，而双向链表则可以自我删除。 2、双向链表基本介绍 双向链表也叫双向表，是链表的一种，它由多个结点组成，每个结点都由一个数据域和两个指针域组成，数据域(data)用来存储数据，其中一个指针域(next)用来指向其后继结点，另一个指针域用来指向前驱结点(prev指针)。链表的头结点的数据域不存储数据，指向前驱结点的指针域值为null，指向后继结点的指针域指向第一
双向链表的实现
QAQ
04-01 762
之前的博客讲到了线性表的链式存储结构，实现了链表的各种操作。但是，单链表有单向性的缺点，为了克服这一缺点，可以尝试实现双向链表。下图是双向链表的结构: 我们也可以实现双向链表的一些基本操作： 以下是实现基本操作的代码：#include <stdio.h> #include <malloc.h> #define OK 1 #define ERROR 0 #define ElemType
Java实现双向链表
weixin_64448174的博客
06-01 4319
一、双向链表的简单理解 1、双向链表是什么？ 在前面的文章中，我们仔细讲解了单向链表，并且用代码实现了单向链表。单向链表的好处很多，虽然单链表能 100% 解决逻辑关系为 "一对一" 数据的存储问题，但在解决某些特殊问题时，单链表并不是效率最优的存储结构。比如说，如果算法中需要大量地找某指定结点的前趋结点，使用单链表无疑是灾难性的，因为单链表更适合 "从前往后" 找，而 "从后往前" 找并不是它的强项，因此我们就有了双向链表这个东西，双向链表顾名思义就是链表的高级版，他与单向链表有所不同的一点在于在具有
双向链表实现一个队列
Edwards_June的专栏
01-14 2878
请自己用双向链表实现一个队列，队列里节点内存的值为int，要求实现入队，出队和查找指定节点的三个功能。 #include using namespace std; typedef struct node { int data; node* prev; node* next; } Node; typedef struct queue { Node* front; Node* rea
【数据结构】双向链表实现
m0_73367097的博客
03-26 1698
双向链表的定义与实现
Java实现双向链表(两个版本)
09-02
主要介绍了Java实现双向链表(两个版本)的相关资料,需要的朋友可以参考下
JS双向链表实现与使用方法示例(增加一个previous属性实现)
01-19
前面一篇讲述了《JS基于对象的链表实现与使用方法》，这里的双向链表通过增加一个previous属性实现。 单链表中若需要查找某一个元素时，必须从第一个元素开始进行查找，而双向链表除开头节点和最后一个节点外每个...
C++ 实现双向链表的实例
08-30
C++ 实现双向链表的实例 本文将详细介绍 C++ 实现双向链表的实例的相关知识点，包括双向链表的概念、实现方法、代码分析等。 双向链表的概念 双向链表是一种特殊的链表结构，它允许在链表中插入、删除节点，并且...
Python单向链表和双向链表原理与用法实例详解
09-20
双向链表（Double Linked List）则在单向链表的基础上增加了对上一个节点的引用，每个节点包含data、next（指向下一个节点）和prev（指向上一个节点）三个属性。这样，双向链表可以从头到尾或者从尾到头遍历，提供了...
21_动态规划与数据结构结合
刘炫320的博客
09-11 517
老鸟：假设你有一个数组arr，你需要多次查询某个子数组arr[i:j]的和。直接计算会很慢，我们可以用动态规划预处理，再用一种数据结构来快速查询。菜鸟：听起来不错，但具体怎么做呢？老鸟：我们可以先构建一个数组prefixSum，其中表示数组arr从起始位置到i的和。这样每次查询arr[i:j]的和时，可以用来快速计算。菜鸟：这样确实能减少计算量，但构建prefixSum数组需要什么操作呢？老鸟：好问题。我们来看看代码示例。老鸟：今天我们讨论了动态规划与数据结构结合的应用，通过prefixSum。
数据结构 Java DS——分享部分链表题目 (2)
cjejwe的博客
09-10 940
关于JAVA的链表,笔者已经写了两篇博客来介绍了,今天给笔者们带来第三篇,也是分享了一些笔者写过的,觉得挺好的题目,链接也已经挂上了,笔者们可以去看看。
[数据结构]二叉搜索树
2302_80220453的博客
09-15 530
今天我们来学习一下新的数据结构，二叉搜索树，这个结构比较简单，是一个铺垫式的结构，为之后的平衡二叉树，AVL树以及红黑树做一个知识基础，我们将从概念到实现具体的介绍二叉搜索树。
数据结构 - 链表
kaneki_lh的博客
09-11 482
listnode;/* 双向链表结构体 */}dlinklist;
数据结构之哈希表
最新发布
weixin_44021343的博客
09-15 249
在顺序表中查找时，需要从表头开始，依次遍历比较a[i]与key的值是否相等，直到相等才返回索引i；在有序表中查找时，我们经常使用的是二分查找，通过比较key与a[i]的大小来折半查找，直到相等时才返回索引i。最终通过索引找到我们要找的元素。但是，这两种方法的效率都依赖于查找中比较的次数。我们有一种想法，能不能不经过比较，而是直接通过关键字key一次得到所要的结果呢？这时，就有了散列表查找。散列表（Hash table，也叫哈希表），是根据关键码值(Key value)而直接进行访问的数据结构。
数据结构 | 栈和队列
TTKunn的博客
09-15 983
本文详细介绍了栈和队列的数据结构及其实现
数据结构：堆排序
2303_78940834的博客
09-15 957
更完堆，再更一期堆排序。
一天一道算法题day02
m0_74004434的博客
09-06 1756
对于 mm 个数组对 (c[i],b)(c[i],b)，即 (c[1],b),(c[2],b),…,(c[m],b)(c[1],b),(c[2],b),…,(c[m],b) ，根据前面的问题要求，分别计算出它们的答案，最后，你要给出所有答案的总和。注意，数组 c[i]c[i] 是从 aa 数组转化而来的。现在，你需要找到最小的操作次数，使得对于所有的 1≤i≤k1≤i≤k ，都有 ai<biai​<bi​。对于每个测试样例，第一行包含两个整数 n,m，表示数组 a,b的大小，以及元素 a1值的上限。
数据结构——链表
2301_76227083的博客
09-11 884
学习了顺序表就知道，顺序表在大量的头插或者中间插入的时候效率是很低的，需要频繁挪动数据，那么有没有一种数据结构在处理大量头插和中间插入的时候效率非常高呢？是有的，今天我们就来学习一下链表。
实现一个双向链表
05-25
好的，下面是一个简单的双向链表的实现，包括节点的添加、删除和打印： ```python class Node: def __init__(self, value): self.value = value self.prev = None self.next = None class DoublyLinkedList: ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值