数据结构-双向循环链表及其封装

最新推荐文章于 2024-10-17 20:50:47 发布
最新推荐文章于 2024-10-17 20:50:47 发布
阅读量132 收藏
点赞数
分类专栏： 数据结构 双向链表 文章标签： 链表 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xiaoyu1381/article/details/126246969
版权

双向循环链表

结点:

    前驱指针  prev

    数据域

    后继指针  next

typedef struct Node

{

    struct Node* node;  //前驱

    TYPE data;

    struct Node* next;  //后继

}Node;

Node* create_node(TYPE data)

{

    Node* node = malloc(sizeof(Node));

    node->data = data;

    node->prev = node;

    node->next = node;

    return node;

}

//带头结点的双向链表

void _add_list(Node* p,Node* n,TYPE data)

{

    Node* node = create_node(data);

    node->prev = p;

    node->next = n;

    p->next = node;

    n->prev = node;

}

//头添加

void add_head_list()

{

    _add_list(head,head->next,data);

}

//尾添加

void add_tail_list(Node* head,TYPE data)

{

    _add_list(head->prev,head,data);

}

//插入

bool insert_list(Node* head,size_t index,TYPE data)

{

    //n直接找到插入的index结点

    Node* n = head->next;

    for(int i = 0;i<index;i++)

    {

        n = n->next;

        if(head == n) return false;

    }

    _add_list(n->prev,n,data);

}

//删除

void _del_list(Node* node)

{

    Node* p = node->prev;

    Node* n = node->next;

    p->next->n;

    n->prev =p;

    free(node);

}

//按位置删除

bool del_index_list(Node* head,size_t index)

{

    //直接找待删除结点即可

    Node* n = head->next;

    for(int i=0;i<index;i++)

    {

        n = n->next;

        if(head == n) return false;

    }

    _del_list(n);

    return true;

}

//按值删除

bool del_value_list(Node* head,TYPE val)

{

    for(Node* n = head->next;head != n;n=n->next)

    {

        if(n->data == val)

        _del_list(n);

        return true;

    }

    return false;

}

//遍历

void show_list(Node* head)

{

    for(Node* n = head->next;head!=n;n=n->next)

    {

        printf("%d ",n->data)

    }

    printf("\n");

}

int main()

{

    Node* head = create_node(0);

    for(int i=0;i<10;i++)

    {

        add_head_list(head,i);

    }

    insert_list(head,4,88);

    show_list(head);

}

封装双向链表

双向链表

结点:

    前驱指针  prev

    数据域

    后继指针  next

数据项：

    头结点

    结点数量

特点：

    1、在任意结点都可以遍历整个链表

    2、相比单链表,删除、插入更直接

    3、已知结点位置,可以选择从前往后或者从后往前,提高链表的访问效率

 #include <stdio.h>

#include <stdlib.h>

#include <stdbool.h>

#define TYPE int

//  封装双向链表

typedef struct Node

{

    struct Node* prev;  //  前驱

    TYPE data;

    struct Node* next;  //  后继

}Node;

//  双向链表都是循环的

Node* create_node(TYPE data)

{

    Node* node = malloc(sizeof(Node));

    node->data = data;

    node->prev = node;

    node->next = node;

    return node;

}

//  双向链表

typedef struct DoubleList

{

    Node* head;

    size_t size;

}DoubleList;

//  创建链表

DoubleList* create_double_list(void)

{

    DoubleList* list = malloc(sizeof(DoubleList));

    list->head = create_node(0);

    list->size = 0;

    return list;

}

//  在前驱和后继之间添加一个新结点

static void _add_list(Node* p,Node* n,TYPE val)

{

    Node* node = create_node(val);

    p->next = node;

    n->prev = node;

    node->next = n;

    node->prev = p;

}

//  删除当前结点

static void _del_list(Node* node)

{

    Node* p = node->prev;

    Node* n = node->next;

    p->next = n;

    n->prev = p;

    free(node);

}

//  返回指定位置的结点

static Node* _index_list(DoubleList* list,size_t index)

{

    if(index >= list->size) return NULL;

    if(index < list->size/2)

    {

        //  从前往后

        Node* n = list->head->next;

        while(index--) n = n->next;

        return n;

    }

    else

    {

        //  往后找

        Node* n = list->head->prev;

        while(++index < list->size) n = n->prev;

        return n;

    }

}

//  返回指定值的结点

static Node* _value_list(DoubleList* list,TYPE data)

{

    for(Node* n=list->head->next; list->head!=n; n=n->next)

    {

        if(data == n->data) return n;  

    }

    return NULL;

}

//  头添加

void add_head_list(DoubleList* list,TYPE val)

{

    _add_list(list->head,list->head->next,val);

    list->size++;

}

//  尾添加

void add_tail_list(DoubleList* list,TYPE val)

{

    _add_list(list->head->prev,list->head,val);

    list->size++;

}

//  插入

bool insert_list(DoubleList* list,size_t index,TYPE val)

{

    Node* n = _index_list(list,index);  

    if(NULL == n) return false;

    _add_list(n->prev,n,val);

    list->size++;

    return true;

}

//  按位置修改

bool modify_index_list(DoubleList* list,size_t index,TYPE val)

{

    Node* node = _index_list(list,index);

    if(NULL == node) return false;

    node->data = val;

    return true;

}

//  按值修改 更新

size_t modify_value_list(DoubleList* list,TYPE old,TYPE val)

{

    size_t cnt = 0;

    for(Node* n=list->head->next; list->head!=n; n=n->next)

    {

        if(old == n->data)

        {

            n->data = val;

            cnt++;

        }  

    }

    return cnt;

}

//  访问

bool access_list(DoubleList* list,size_t index,TYPE* val)

{

    Node* node = _index_list(list,index);

    if(NULL == node) return false;

   

    *val = node->data;

    return true;

}

//  查询

int query_list(DoubleList* list,TYPE val)

{  

    Node* n = list->head->next;

    for(int i=0; i<list->size; i++)

    {

        if(val == n->data) return i;

        n = n->next;

    }

    return -1;

}

//  按位置删除

bool del_index_list(DoubleList* list,size_t index)

{

    Node* node = _index_list(list,index);

    if(NULL == node) return false;

    _del_list(node);

    list->size--;

    return true;

}

//  按值删除

bool del_value_list(DoubleList* list,TYPE val)

{

    Node* node = _value_list(list,val);

    if(NULL == node) return false;

    _del_list(node);

    list->size--;

    return true;

}

//  遍历

void show_list(DoubleList* list)

{

    for(Node* n=list->head->next; list->head!=n; n=n->next)

    {

        printf("%d ",n->data);  

    }

    printf("\n");

}

//  清空

void clear_list(DoubleList* list)

{

    Node* n = list->head->next;

    while(list->head!=n)

    {

        Node* temp = n;

        n = n->next;

        free(temp);

    }

    list->head->next = list->head;

    list->head->prev = list->head;

    list->size = 0;

}

//  销毁

void destory_list(DoubleList* list)

{

    clear_list(list);

    free(list->head);

    free(list);

}

int main()

{

    DoubleList* list = create_double_list();

    for(int i=0; i<10; i++)

    {

        add_tail_list(list,i);  

    }

    show_list(list);

    insert_list(list,6,88);

    insert_list(list,6,88);

    insert_list(list,6,88);

    insert_list(list,6,88);

    show_list(list);

    TYPE num = -100;

    access_list(list,1,&num);

    printf("num=%d\n",num);

    modify_index_list(list,6,77);

    show_list(list);

    del_index_list(list,1);

    show_list(list);

    del_value_list(list,99);

    modify_value_list(list,88,22);

    show_list(list);

    printf("index=%d\n",query_list(list,90));

    destory_list(list);

}

xiaoyu1381
关注
专栏目录
双向循环链表的模板封装
freex64的专栏
03-09 194
程序员对双向循环链表的熟悉程度，那就像周星扮演的唐伯虎说《椿树秋香图》一样——“画了几百次啦，熟得很”！。所以直接进入正题模板封装，封装之后模板名称是rubbish::structlist。
数据结构——单向循环链表&双向循环链表
qq_56668869的博客
08-24 3260
数据结构、单向循环链表、程序实现单向循环链表、方法操作示例、双向循环链表、程序实现双向循环链表
双向链表的封装
qq_36963007的博客
03-21 131
function DoublyLinkedList(){ function Node(data){ this.data = data this.prev = null this.next = null } this.head = null this.tail = null this.length = 0 //append方法 DoublyLinkedList.prototype.append = func
将多项式的系数cof，项deg,放进node,然后将node放进list里
jasscical's blog
05-27 543
收获： 1.引入库： #include 使用list容器 #include<iostream> 使用cout\cin #include<fstream> 操作文件 #include<sstream> 字符串流（格式转换） #include <cmath> 使用数学函数 #include <string> string操作 2.自己...
结构体定义 typedef struct LNode 用法说明
热门推荐
qq_41148224的博客
06-10 2万+
最近复习数据结构，对链表的定义进行下说明： 将typedef和结构体的定义和结构体指针的定义连在一起写，精简为如下代码： typedef struct LNode{ ElemType data; struct LNode *next; }LNode,*LinkList; 将精简代码还原： struct LNode { ElemType data; str...
一元多项式的基本操作
qq_41678405的博客
04-28 859
#include &lt;stdio.h&gt;#include &lt;malloc.h&gt;typedef struct lnode{ float cof; int exp; struct lnode *next;}lnode;void creat(lnode *h,int n){ lnode *t,*p; t=h; for(int i=0;i&lt;n;i++) { p=(lnode*)...
C-数据结构-双向循环链表
aqiangdeba的博客
05-23 1029
常用的双向循环链表，不易出错 /* 通用性比较强的双向环链为了函数的通用性，我们在.h .c 需要用户去定夺的关键字，内容全部做成通用的接口 利用typedef抽象出了一些接口比较统一的实现方法 */llist.h llist.c main.c Makefile 补充说明 在C语言中， 关键字用于给现有的数据类型定义一个新的名字。你提供的 是一个非常有用的技巧，特别是在定义函数指针类型时。我们来详细解释一下这个定义。原始定义： 这行代码声明了一个函数类型 ，它接受一个 类型的参数，并且没有返回值（）。
Java就业冲刺之数据结构-递归-双向链表-树
m0_72568513的博客
07-04 206
删除的节点只有一颗子树,让该节点的父节点的left/right,指向删除节点的子节点即可。删除的节点有两颗子树,让删除节点的前驱节点/后继节点来替换该节点,才能保证树已让是有序的。删除的是叶子节点,此时直接删除即可,让其父节点指向该节点的引用置为null,即可。增删元素:(默认在尾部添加)将链断开,然后重新链接,从而实现添加/删除元素。为了避免失衡二叉树,对二叉排序树进行了优化,产生了两种新的数据结构。查找元素: get(int index):E。Comparator–外比较器。
C语言之航空信息查询系统-使用双向循环链表实现系统的增删改查操作
09-20
在本项目中，我们利用C语言构建了一个航空信息查询系统，该系统的核心数据结构是双向循环链表。双向循环链表是一种特殊的链式存储结构，它允许我们在链表的两个方向上进行遍历，这对于执行增删改查操作非常有用。...
带头结点的双向循环链表
07-17
总结来说，带头结点的双向循环链表是一种灵活且实用的数据结构，它在C++中的实现涉及节点定义、链表操作的实现以及封装为类。理解并掌握这一数据结构对于提升编程能力，尤其是处理复杂算法问题具有重要意义。
基于C++数据结构双向循环链表实现的贪吃蛇【100010175】
12-26
结构：把相应的功能模块化，结构化，封装成一个个函数，像蛇逻辑有自噬死亡，撞墙死亡，吃食，变长等 交互：在相应的自定义逻辑函数中调用各自的函数，主函数则主要写下简短的循环框架，直到游戏结束
typedef struct lnode(结构体及结构体指针)解惑
dhuqsh的博客
07-29 7224
/* 数据结构解惑01  在数据结构中会看到 typedef struct QNode { QElemType data; //数据域  struct QNode *next; //指针域  }QNode,*QueuePtr; typedef struct { QueuePtr front; //队头指针 QueuePtr rear; //队尾指针  };
第四周项目六（1）
lihao66886的博客
09-23 469
/*问题及代码 *Copyright(c)2015,烟台大学计算机学院 *All right reserved. *文件名称：存储多项式的数据结构.cpp *作者：李浩 *完成日期；2015年9月23日 *版本号；v1.0 * *问题描述：　　存储多项式的数据结构 　　多项式的通式是p n (x)=a n x n +a n?1 x n?1 +...+a 1 x+
将多项式的系数cof，项deg,放进node,然后将node放进map里
jasscical's blog
05-27 357
1.map用法 2.跟使用list方式不一样的地方： map<int,double> maptest 迭代器定义：map<int,double> :: iterator iter = maptest.begin(); 除了前面类型 map<int,double> 跟list不一样，定义的其他跟list一样 2.1 取值方式。 iter->first,ite...
【数据结构】宜宾大学-计院-实验三
2303_80737493的博客
10-17 770
线性表的应用——实现两多项式的相加 课前准备： 实验学时：2 实验目的： 实验内容： 实验结果： 实验报告:（及时撰写实验报告） 实验测试结果： 代码实现：（C/C++）【含注释】
《数据结构》学习系列——树（中）
Kenjuan的博客
10-17 1184
通过遍历二叉树可得到一个结点的一个线性序列，在线性序列中，除第一个结点外, 每个结点有且仅有一个前驱，除最后一个结点外，每个结点有且仅有一个后继，但是在二叉树中只能找到结点的左孩子、右孩子，结点在线性序列中的前驱和后继只有在遍历过程中才能得到为了与结点在二叉树中所具有的前驱(即父结点)和后继(即子结点)区别开来，通常把某种序列中结点的前驱或后继冠以某种遍历的名称，如把中根序列中结点的前驱称作中根前驱，结点的后继称作中根后继设 T是由增加某种遍历顺序的线索域的结点所构成的一棵二叉树，在 T。
数据结构 —— 链式二叉树（C语言讲解）
最新发布
知其然 知其所以然
10-17 1100
本篇文章主要讲解链式存储的二叉树，如果读者不清楚二叉树的基础知识，推荐阅读数据结构——树和二叉树简介。对于二叉树这种数据结构的学习，重点不是增删改查，而是学习这种结构，所以，主要讲解一些链式二叉树的操作。
结构体通讲——数据结构解惑
weixin_73236117的博客
10-17 475
结构：一个变量里包含很多变量。
优先级队列和PriorityQueue
2301_79985750的博客
10-17 724
优先级队列是一种特殊的队列，每个元素都有一个优先级或者权重，与普通队列的先进先出不同，它按照优先级的大小从高到低进行排序，优先级最高的优先出队列。在任务调度，事件模拟中发挥着重要的作用。Java中的优先级队列是一种利用堆这种数据结构进行实现，按照数据的优先级顺序进行排序，可以任意的顺序插入，但是取出时按照规定好的优先级进行操作。
数据结构：双向循环链表的操作与实现
"这篇资料主要涉及数据结构中的双向循环链表及其相关操作，包括链表的基本概念、单链表的特点、存储映像、类定义以及单链表的插入与删除等操作。" 在数据结构中，链表是一种重要的数据结构，它不同于数组，其元素在...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

xiaoyu1381

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值