数据结构 双向循环链表

最新推荐文章于 2024-10-18 15:58:19 发布
最新推荐文章于 2024-10-18 15:58:19 发布
阅读量1k 收藏 2
点赞数
分类专栏： 总结 文章标签： 链表 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45680532/article/details/125630336
版权

文章目录

双向循环链表

定义

  • 记录元素的同时要记录前一个结点和后一个结点的地址
  • 再头尾插入删除结点 时间复杂度O(1)
ElemType elem;
struct DNode *prev;
struct DNode *next;
  • 用柔性数组实现 任意类型元素双向循环链表
// struct DNode *node = (struct DNode*)malloc(DNODESIZE + elemSize);
// elemSize 是要存储元素类型的字节数
struct DNode *prev;
struct DNode *next;
char elem[0]; // 柔性数组

双向循环链表实现

结构体定义

#define SUCCESS 0
#define FAILURE -1

typedef int ElemType;

// 双向(循环)链表结点
struct DNode {
    ElemType elem; // 元素
    struct DNode *prev; // 指向上一个结点
    struct DNode *next; // 指向下一个结点
};

#define DNODESIZE sizeof(struct DNode)

// 双向循环链表类型
typedef struct DNode* DLinkedList;

静态函数列表

// 创建双向(循环)链表的结点
static struct DNode *create_dnode(ElemType elem, struct DNode *prev, struct DNode *next);

// 再结点node后面插入结点
static int insert_after(struct DNode *node, ElemType elem);

// 再结点node前面插入结点
static int insert_before(struct DNode *node, ElemType elem);

// 删除node结点
static int delete_dnode(struct DNode *node, ElemType *pElem);

// 获取pos位置上结点
struct DNode *get_dnode(DLinkedList list, size_t pos);

基础函数声明

// 创建双向循环链表   创建一个头结点   且让头结点的prev和next指向头结点
// 头结点本身不存在数据
DLinkedList create_dlinkedlist(void);

// 双向链表是否为空
bool empty_dlinkedlist(DLinkedList list);

// 双向循环链表元素个数
size_t size_dlinkedlist(DLinkedList list);

// 清空双向循环链表
void clear_dlinkedlist(DLinkedList list);

// 销毁双向循环链表
void destroy_dlinkedlist(DLinkedList list);

// 在头部插入元素
int push_front_dlinkedlist(DLinkedList list, ElemType elem);

// 在末尾插入元素
int push_back_dlinkedlist(DLinkedList list, ElemType elem);

// 在指定位置插入元素
int insert_dlinkedlist(DLinkedList list, size_t pos, ElemType elem);

// 在头部删除元素
int pop_front_dlinkedlist(DLinkedList list, ElemType *pElem);

// 在末尾删除元素
int pop_back_dlinkedlist(DLinkedList list, ElemType *pElem);

// 删除指定位置的元素
int remove_dlinkedlist(DLinkedList list, size_t pos, ElemType *pElem);

// 根据值删除元素
int delete_dlinkedlist(DLinkedList list, ElemType elem, size_t n);

// 根据条件删除元素
int delete_condition_dlinkedlist(DLinkedList list, bool (*condition)(ElemType), size_t n);

// 修改pos位置的元素
int update_dlinkedlist(DLinkedList list, size_t pos, ElemType newElem);

// 修改第n个oldElem为newElem
int update_elem_dlinkedlist(DLinkedList list, ElemType oldElem, ElemType newElem, size_t n);

// 修改第n个满足条件的元素为newElem
int update_condition_dlinkedlist(DLinkedList list, bool (*condition)(ElemType), ElemType newElem, size_t n);

// 查找pos位置的元素
ElemType* elem_of_dlinkedlist(DLinkedList list, size_t pos);

// 统计元素为elem的个数
int count_dlinkedlist(DLinkedList list, ElemType elem);

// 统计满足条件元素的个数
int count_condition_dlinkedlist(DLinkedList list, bool (*condition)(ElemType));

// 查找elem元素位置
int find_dlinkedlist(DLinkedList list, ElemType elem, size_t n);

// 查找满足条件的元素位置
int find_condition_dlinkedlist(DLinkedList list, bool (*condition)(ElemType), size_t n);

// 正向迭代
void foreach_dlinkedlist(DLinkedList list, void (*foreach)(ElemType*));

// 反向迭代
void reverse_foreach_dlinkedlist(DLinkedList list, void (*foreach)(ElemType*));

静态函数实现

创建双向(循环)链表的结点 create_dnode
static struct DNode *create_dnode(ElemType elem, struct DNode *prev, struct DNode *next) {
    struct DNode *node = (struct DNode*)malloc(DNODESIZE);
    if (node != NULL) { // 申请成功  赋值
        node->elem = elem;
        node->prev = prev;
        node->next = next;
    }
    return node;
}
再结点node后面插入结点 insert_after
// 在结点1后面插入元素
/*
node为结点1，node->next为结点3，要插入结点2(prev已经指向结点1，next已经指向结点3)
先将结点3的prev指向结点2
再将结点1的next指向结点2
*/
static int insert_after(struct DNode *node, ElemType elem) {
    struct DNode *insNode = create_dnode(elem, node, node->next); // 结点2
    if (insNode == NULL) {
        return FAILURE;
    }
    node->next->prev = insNode; // 结点3的prev指向结点2
    node->next = insNode; // 结点1的next指向结点2
    return SUCCESS;
}
再结点node前面插入结点 insert_before
// 在结点1前面插入元素
/*
node为结点1，node->prev为结点3，要插入结点2(prev已经指向结点3，next已经指向结点1)
先将结点3的next指向结点2
再将结点1的prev指向结点2
*/
static int insert_before(struct DNode *node, ElemType elem) {
    struct DNode *insNode = create_dnode(elem, node->prev, node); // 结点2
    if (insNode == NULL) {
        return FAILURE;
    }
    node->prev->next = insNode; // 结点3的next指向结点2
    node->prev = insNode; // 将结点1的prev指向结点2
    return SUCCESS;
}
删除node结点 delete_dnode
// 删除node结点
static int delete_dnode(struct DNode *node, ElemType *pElem) {
    if (pElem != NULL) {
        *pElem = node->elem; // 返回删除的元素
    }
    node->next->prev = node->prev;
    node->prev->next = node->next;
    free(node); // 释放删除的结点
    return SUCCESS;
}
获取pos位置上结点 get_dnode
// 获取pos位置上结点
struct DNode *get_dnode(DLinkedList list, size_t pos) {
    struct DNode *node = list->next;
    size_t i;
    for (i = 1; i < pos && node != list; ++i) {
        node = node->next;
    }
    if (node == list && i < pos) {
        return NULL;
    }
    return node;
}

基础函数实现

创建双向循环链表 create_dlinkedlist
// 创建一个头结点   且让头结点的prev和next指向头结点
// 头结点本身不存在数据
DLinkedList create_dlinkedlist(void) {
    DLinkedList list = (DLinkedList)malloc(DNODESIZE);
    if (list != NULL) {
        list->prev = list->next = list; // 没有元素所以指针都指向自己
    }
    return list;
}
双向链表是否为空 empty_dlinkedlist
// 双向链表是否为空
bool empty_dlinkedlist(DLinkedList list) {
    assert(list != NULL);
    return list->prev == list && list->next == list; // 等于自己就为空
}
双向循环链表元素个数 size_dlinkedlist
size_t size_dlinkedlist(DLinkedList list) {
    assert(list != NULL);
    size_t size = 0;
    struct DNode *node;
    for (node = list->next; node != list; node = node->next) { // 循环到头结点结束
        ++size;
    }
    return size;
}
清空双向循环链表 clear_dlinkedlist
void clear_dlinkedlist(DLinkedList list) {
    assert(list != NULL);
    struct DNode *node, *next;
    for (node = list->next; node != list; node = node->next) {
        next = node->next; // 先记录下一个地址
        free(node); // 每个结点都要释放，否在会导致内存泄漏
    }
    list->prev = list->next = list;
}
销毁双向循环链表 destroy_dlinkedlist
void destroy_dlinkedlist(DLinkedList list) {
    assert(list != NULL);
    clear_dlinkedlist(list);
    free(list);
}
在头部插入元素 push_front_dlinkedlist
int push_front_dlinkedlist(DLinkedList list, ElemType elem) {
    assert(list != NULL);
    return insert_after(list, elem); // 调用静态函数
    // return insert_before(list->next, elem);
}
在末尾插入元素 push_back_dlinkedlist
int push_back_dlinkedlist(DLinkedList list, ElemType elem) {
    assert(list != NULL);
    return insert_before(list, elem);
    // return insert_after(list->prev, elem);
}
在指定位置插入元素 insert_dlinkedlist
int insert_dlinkedlist(DLinkedList list, size_t pos, ElemType elem) {
    assert(list != NULL);
    if (pos == 0) {
        return FAILURE;
    }
    struct DNode *node = get_dnode(list, pos); // 先获取指定位置的元素  然后再其之前插入元素
    if (node == NULL) {
        return FAILURE;
    }
    return insert_before(node, elem);
}
在头部删除元素 pop_front_dlinkedlist
int pop_front_dlinkedlist(DLinkedList list, ElemType *pElem) {
    assert(list != NULL);
    if (list->next == list) {
        return FAILURE;
    }
    return delete_dnode(list->next, pElem);
}
在末尾删除元素 pop_back_dlinkedlist
int pop_back_dlinkedlist(DLinkedList list, ElemType *pElem) {
    assert(list != NULL);
    if (list->prev == list) {
        return FAILURE;
    }
    return delete_dnode(list->prev, pElem);
}
删除指定位置的元素 remove_dlinkedlist
int remove_dlinkedlist(DLinkedList list, size_t pos, ElemType *pElem) {
    assert(list != NULL);
    if (pos == 0) {
        return FAILURE;
    }
    struct DNode *node = get_dnode(list, pos); // 先获取要删除元素的结点地址
    if (node == NULL || node == list) {
        return FAILURE;
    }
    return delete_dnode(node, pElem);
}
根据值删除元素 delete_dlinkedlist

n为0全部删除

int delete_dlinkedlist(DLinkedList list, ElemType elem, size_t n) {
    assert(list != NULL);
    struct DNode *node = list->next;
    struct DNode *next = NULL;
    int cnt = 0;
    while (node != list) {
        if (node->elem == elem) {
            if (n == 0) {
                next = node->next;
                delete_dnode(node, NULL);
                node = next;
                ++cnt;
            } else {
                if (--n == 0) {
                    delete_dnode(node, NULL);
                    return 1;
                } else {
                    node = node->next; // n不为零 向后移
                }
            }
        } else {
            node = node->next; // 不等于elem 向后移
        }
    }
    return cnt;
}
根据条件删除元素 delete_condition_dlinkedlist

自定义回调函数condition n为0全部删除

int delete_condition_dlinkedlist(DLinkedList list, bool (*condition)(ElemType), size_t n) {
    assert(list != NULL && condition != NULL);
    struct DNode *node = list->next;
    struct DNode *next = NULL;
    int cnt = 0;
    while (node != list) {
        if (condition(node->elem)) {
            if (n == 0) {
                next = node->next;
                delete_dnode(node, NULL);
                node = next;
                ++cnt;
            } else {
                if (--n == 0) {
                    delete_dnode(node, NULL);
                    return 1;
                } else {
                    node = node->next;
                }
            }
        } else {
            node = node->next;
        }
    }
    return cnt;
}
修改pos位置的元素 update_dlinkedlist
int update_dlinkedlist(DLinkedList list, size_t pos, ElemType newElem) {
    assert(list != NULL);
    if (pos == 0) {
        return FAILURE;
    }
    struct DNode *node = get_dnode(list, pos); // 获取要修改元素的地址
    if (node == NULL || node == list) {
        return FAILURE;
    }
    node->elem = newElem;
    return SUCCESS;
}
修改第n个oldElem为newElem update_elem_dlinkedlistElemType newElem, size_t n);

n为0全部修改

int update_elem_dlinkedlist(DLinkedList list, ElemType oldElem, ElemType newElem, size_t n) {
    assert(list != NULL);
    int cnt = 0;
    struct DNode *node = list->next;
    for (; node != list; node = node->next) {
        if (node->elem == oldElem) {
            if (n == 0) {
                node->elem = newElem;
                ++cnt;
            } else {
                if (--n == 0) {
                    node->elem = newElem;
                    return 1;
                }
            }
        }
    }
    return cnt;
}
修改第n个满足条件的元素为newElem update_condition_dlinkedlist

自定义回调函数condition n为0全部修改

int update_condition_dlinkedlist(DLinkedList list, bool (*condition)(ElemType), ElemType newElem, size_t n) {
    assert(list != NULL && condition != NULL);
    int cnt = 0;
    struct DNode *node = list->next;
    for (; node != list; node = node->next) {
        if (condition(node->elem)) {
            if (n == 0) {
                node->elem = newElem;
                ++cnt;
            } else {
                if (--n == 0) {
                    node->elem = newElem;
                    return 1;
                }
            }
        }
    }
    return cnt;
}
查找pos位置的元素 Type* elem_of_dlinkedlist
ElemType* elem_of_dlinkedlist(DLinkedList list, size_t pos) {
    assert(list != NULL);
    if (pos == 0) {
        return NULL;
    }
    struct DNode *node = get_dnode(list, pos);
    if (node == NULL || node == list) {
        return NULL;
    }
    return &node->elem; // 返回地址
}
统计元素为elem的个数 count_dlinkedlist
int count_dlinkedlist(DLinkedList list, ElemType elem) {
    assert(list != NULL);
    int cnt = 0;
    struct DNode *node = list->next;
    for (; node != list; node = node->next) {
        if (node->elem == elem) {
            ++cnt;
        }
    }
    return cnt;
}
统计满足条件元素的个数 count_condition_dlinkedlist

自定义回调函数condition

int count_condition_dlinkedlist(DLinkedList list, bool (*condition)(ElemType)) {
    assert(list != NULL && condition != NULL);
    int cnt = 0;
    struct DNode *node = list->next;
    for (; node != list; node = node->next) {
        if (condition(node->elem)) {
            ++cnt;
        }
    }
    return cnt;
}
查找elem元素位置 find_dlinkedlist
int find_dlinkedlist(DLinkedList list, ElemType elem, size_t n) {
    assert(list != NULL);
    if (n == 0) {
        return 0;
    }
    struct DNode *node = list->next;
    size_t pos = 0;
    for (; node != list; node = node->next) {
        ++pos;
        if (node->elem == elem) {
            if (--n == 0) {
                return pos;
            }
        }
    }
    return 0; // 0为没有找到
}
查找满足条件的元素位置 find_condition_dlinkedlist

自定义回调函数condition

int find_condition_dlinkedlist(DLinkedList list, bool (*condition)(ElemType), size_t n) {
    assert(list != NULL && condition != NULL);
    if (n == 0) {
        return 0;
    }
    struct DNode *node = list->next;
    size_t pos = 0;
    for (; node != list; node = node->next) {
        ++pos;
        if (condition(node->elem)) {
            if (--n == 0) {
                return pos;
            }
        }
    }
    return 0;
}
正向迭代 foreach_dlinkedlist

可以实现打印等功能

void foreach_dlinkedlist(DLinkedList list, void (*foreach)(ElemType*)) {
    assert(list != NULL && foreach != NULL);
    struct DNode *node;
    for (node = list->next; node != list; node = node->next) {
        foreach(&node->elem);
    }
}
反向迭代 reverse_foreach_dlinkedlist
void reverse_foreach_dlinkedlist(DLinkedList list, void (*foreach)(ElemType*)) {
    assert(list != NULL && foreach != NULL);
    struct DNode *node;
    for (node = list->prev; node != list; node = node->prev) {
        foreach(&node->elem);
    }
}
LimboMaster
关注
专栏目录
数据结构— 循环链表、双向链表【插入&删除】、双向循环链表
四季轮换叶，一路招摇胜
03-31 5807
循环链表也称为环形链表，其结构与单链表相似，只是将单链表的首尾相连。将最后一个结点的后继指针指向第一个结点。
数据结构之双向循环链表
未思
02-06 945
算法与数据结构之双向循环链表
【数据结构】双向循环链表
xing1584114471的博客
10-10 397
（近期我在学习数据结构，于是我自己整理了单链表、循环单链表、双向链表、双向循环链表的相关代码，以巩固这段时间的学习，也希望能够帮助初学者，希望大家在阅读以下代码时发现问题纠正于我，一起探讨） CycDoubleList.h #ifndef __CYCDOUBLELISH_H #define __CYCDOUBLELISH_H #include<stdio.h> #include...
数据结构-双向循环链表
有朋自远方来，不亦乐乎。
08-05 247
通过向 main 函数中调用 initLine 函数，就可以成功创建一个存储有。当问题中涉及到需要 "循环往复" 地遍历表中数据时，就需要使用双向循环链表。单链表通过首尾连接可以构成单向循环链表。数据的双向循环链表，双向链表进行首尾连接。...
数据结构——循环双链表
最新发布
2302_80756830的博客
10-18 369
基于单链表实现循环双链表；相比于单链表，循环双链表的数据结点有两个指针，分别指向该节点的上一个数据节点（前驱）和下一个数据结点（后继），且头结点或首元结点的前驱指向链表的最后一个数据结点，而最后一个数据结点的后继指向头结点或首元结点。因为该结构是循环结构，当指针p再次指向头结点时表示链表循环一周。指针next指向后继结点，prior指向前驱结点。初始化时头结点的前驱和后继都指向自身。若头结点的前驱与后继相等，则说明表空。2、3必须在4的前面。
数据结构(双向循环链表)
icfhsfmf的专栏
07-30 573
问题abcd...26个字母， 控制台输入3， 则显示defghijklmnopqrstuvwxyzabc， 控制台输入-3 则显示xyzabcdefghijklmnopqrstuvw 使用双向链表实现的代码如下:#include <stdio.h> #include <stdlib.h>#define OK 1 #define ERROR 0typedef char ElemType; ty
基于C++数据结构双向循环链表实现的贪吃蛇【100010175】
12-26
蛇：蛇的身体可以看作是链表的节点，当蛇吃到食物时，就增加一节链表节点 食物：相应地在边界内随机生成 蛇的移动：取得上下左右键的ASCII码的键值，通过switch语句响应相应的键值对，实现蛇的方向获取 闪烁问题：...
C语言数据结构之双向循环链表的实例
08-30
C语言数据结构之双向循环链表的实例 在计算机科学中，链表是一种常用的数据结构，它可以动态地分配内存来存储数据，且可以随机访问和插入、删除数据。双向循环链表是一种特殊的链表，它可以同时在链表的头部和尾部...
数据结构双向循环链表
09-27
双向循环链表是一种链表结构，它的每个节点除了有指向下一个节点的指针外，还有指向前一个节点的指针。而且链表的首尾节点相互连接，形成一个环形结构。 相比于单向链表，双向循环链表的优点在于可以方便地进行双向...
python实现数据结构中双向循环链表操作的示例
12-16
双向循环链表是一种重要的数据结构，它允许我们在链表的两端进行插入和删除操作，同时每个节点都包含指向其前一个和后一个节点的引用，形成一个闭合的循环。在给定的示例中，我们看到了如何用Python实现这种数据结构...
数据结构--双向循环链表
RookiChen的博客
05-20 579
上个文章写了循环链表是如何实现的，本文的双向循环链表和循环链表类似，只不过是讲每个节点的prior指向上一个节点，再讲尾结点指向头结点，形成了一个环，双向循环链表的优点就是在查找数据时可以进行双向查找，效率比普通链表要高。 双向循环链表中每个节点定义了两个指针，next（指向下一个）和prior（指向上一个）。 增加：在增加结束前的操作和单链表相同，只是在结尾处要讲头节点的prior指向尾节点，尾节点的next指向头节点。详细代码请看下面的Add函数。 删除：删除时要进行判断删除的节点是否是头结点，详情请.
数据结构——双向循环链表
qq_67611811的博客
08-28 2305
双向循环链表，在原单链表的基础上多了一个指向上一个结点的前驱指针prev，这样前后结点就不仅仅有了单向的从头至尾的指向顺序，也可以从后指向前，从末结点指向头结点。双向带头循环链表结构} DGR;加入前驱指针后，不管是对于链表数据的尾插尾删，或是头插头删，其时间复杂度都为O(1)，大大简化了链表遍历过程，而可以直接在链表首尾增减数据，因为一个链表的末节点可由头结点的前驱指针直接访问而不需要遍历至尾。为了简化文本描述，本章双向循环带头链表均简称为双向链表。...
数据结构-循环双链表
lzlyxxn的博客
05-08 1528
循环链表，就是把链表给首尾相连，即尾结点的next指向L头结点，而循环双链表不仅尾结点指向头结点，且头结点的prior指向尾结点，判断为空时，只要看尾结点下一个是否指向头结点，循环链表的操作和链表的操作差别并不大。 循环双链表的创建、插入、删除 #include<iostream> #include<cstdlib> using namespace std; typedef int ElemType; typedef struct CNode{ ElemType data;
数据结构-----双向循环链表
qq_38345598的博客
10-13 245
瞎扯:白天被迫改一个重现都无法重现的错误.各种百度，各种测试,头发掉了一地，然鹅还是没解决出来 。所以晚上复习数据结构放松一下                                 DualCircleLinkList.h的代码(你也可以省略函数声明) typedef int status; typedef int ElemType; typedef struct Dua...
苦逼的双向循环链表
weixin_30737433的博客
04-02 107
以前不怎么写链表，更不怎么用C++写链表，导致这次写双向循环的时候直接萎了。 其实思想很简单，就是细节比较多…… 别的不说了，直接上代码。（第一，这个不是我写的，第二，这个是C） typedef int elemtype;typedef struct lnode //定义结点类型{ elemtype data; struct lnode *next; struct lnode *pri...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值