[数据结构和算法]C/C++双向循环链表实现(增删改查排序)

最新推荐文章于 2023-09-02 15:40:18 发布
最新推荐文章于 2023-09-02 15:40:18 发布
阅读量1.7k 收藏 16
点赞数 4
分类专栏： 数据结构和算法 文章标签： 数据结构预算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/slimmm/article/details/84317806
版权

之前也写过一篇C语言实现简单的双向循环链表，现在使用C++再来扩展一下内容。除了节点的插入、删除，还增加了一些链表的其他操作，包括节点修改、节点替换、节点查找、值查找、值排序等等。内容还是挺丰富的，废话不多说，上代码吧，有问题的欢迎提出来

定义数据结构

顺便，一些简单的函数就在类中实现了

class node{
    public:
        node *prev;
        node *next;
        uint32_t data;
};

typedef class node Node,*pNode;
class list:public node{
    public:
        list(){ 	//构造一个链表头
            head = new Node;
            list_len = 0;
            head->prev = head;
            head->next = head;
            list_len++;
            cout << "list Head:" << head << endl;  
        }
        ~list(){
            head = NULL;
            delete head;
        }

        //add and delete
        pNode list_addhead(uint32_t dat);	//头插
        pNode list_addtail(uint32_t dat);		//尾插
        pNode list_add(uint16_t coord, uint32_t dat);	//按位置插入
        pNode list_delhead(void);	//头删
        pNode list_deltail(void);	//尾删
        pNode list_del(uint16_t coord);	//按位置删除
        pNode list_delnode(pNode node);	//按节点地址删除

        //find and change
        pNode list_sortval(void);	//值排序，交换值，不改变节点
        pNode list_sortnode(void);	//值排序，直接交换节点
        pNode list_findval(uint32_t dat);   //值查找
        uint32_t list_findcursor(uint16_t cnt);	//位置查找
        pNode list_changeval(uint32_t src_dat, uint32_t des_dat){	//修改值
            pNode tmp = NULL;
            tmp = list_findval(src_dat);
            if(tmp != head){    //find  effective value
                tmp->data = des_dat;
            }
            return head;
        }
        pNode list_changecursorval(uint16_t cnt, uint32_t des_dat){	//修改特定位置的值
            if(cnt >= get_list_len()){
                cout << "param error!!!" << endl;
                return 0;
            }
            pNode tmp = head;
            while(cnt--){
                tmp = tmp->next;
            }
            tmp->data = des_dat;
            return head;
        }
        pNode list_getnode(uint16_t cnt){	//获取节点位置
            if(cnt == 0 || cnt >= get_list_len()){
                cout << "param error!!!" << endl;
                return 0;
            }
            cout << "cnt: " << cnt <<"\t";
            pNode tmp = head;
            while(cnt--){
                tmp = tmp->next;
            }
            return tmp;
        }
        pNode list_changenode(pNode src_node, pNode des_node);	//交换节点
        uint32_t get_list_len(void){	//获取链表长度
            return list_len;
        }

        pNode list_clear(void){	//清除链表
            pNode cursor = head->next;
            while(cursor != head){
                head->next = cursor->next;
                cursor->next->prev = head;
                list_len--;
                cursor = cursor->next;
                delete(cursor);
            }
            return head;
        }

        void list_print(void){	//链表打印
            if(NULL == head){
                cout << "head point empty!!!" << endl;
                return;
            }
            if(head == head->next){
                cout << "List empty" << endl;
                return;
            }
            pNode tmp = head->next;
            while(tmp != head){
                cout << "P:" << tmp << "\tData:" << tmp->data+0 << endl;
                tmp = tmp->next;
            }
        }
    protected:
    private:
        pNode head = NULL;	
        uint16_t list_len;
};
链表的插入
pNode list::list_addhead(uint32_t dat){
    if(NULL == head)    list();
    pNode tmp = new Node;
    if(tmp == head) tmp = new Node;
    list_len++;
    tmp->next = head->next;
    tmp->prev = head;
    head->next->prev = tmp;
    head->next = tmp;
    tmp->data = dat;
    return head;
}

pNode list::list_addtail(uint32_t dat){
    if(NULL == head)    list();
    pNode tmp = new Node;
    list_len++;
    tmp->prev = head->prev;
    tmp->next = head;
    head->prev->next = tmp;
    head->prev = tmp;
    tmp->data = dat;
    return head;
}

pNode list::list_add(uint16_t coord, uint32_t dat){
    if(NULL == head)    list();
    pNode tmp = new Node;
    pNode cursor = head->next;
    list_len++;
    while(coord--){
        cursor = cursor->next;
    }
    tmp->prev = cursor->prev;
    tmp->next = cursor;
    cursor->prev->next = tmp;
    cursor->prev = tmp;
    tmp->data = dat;
    return head;
}
链表的删除
pNode list::list_delhead(void){
    if((NULL==head) || (head->next==head)){
        cout << "List is empty" << endl;
        return head;
    }
    pNode tmp = head->next;
    head->next = tmp->next;
    tmp->next->prev = head;
    list_len--;
    delete tmp;
}
pNode list::list_deltail(void){
    if((NULL==head) || (head->next==head)){
        cout << "List is empty" << endl;
        return head;
    }
    pNode tmp = head->prev;
    head->prev = tmp->prev;
    tmp->prev->next = head;
    list_len--;
    delete tmp;
}
pNode list::list_del(uint16_t coord){
    if((NULL==head) || (head->next==head)){
        cout << "List is empty" << endl;
        return head;
    }
    if(coord >= get_list_len()){
        cout << "param error!!!" << endl;
        return head;
    }
    pNode cursor = head->next;
    pNode tmp = NULL;
    while(coord--){
        cursor = cursor->next;
    }
    tmp = cursor;
    cursor->prev->next = cursor->next;
    cursor->next->prev = cursor->prev;
    list_len--;
    delete cursor;
}
pNode list::list_delnode(pNode node){
    pNode tmp = head->next;
    while(tmp != head){
        if(node == tmp){
            node->prev->next = node->next;
            node->next->prev = node->prev;
            list_len--;
            delete node;
            cout << "delete Node success" << endl;
            return head;
        }
        tmp = tmp->next;
    }
    cout << "Not find this Node" << endl;
    return head;
}
链表的查找

链表的值查找：检索链表是是否有该值，有的话返回该节点的位置；
链表的位置查找：查找链表的第n个节点的值是多少，并返回该值；

pNode list::list_findval(uint32_t dat){
    pNode tmp = head->next;
    while(tmp != head){
        if(dat == tmp->data){
            cout << "find dat:" << dat << "\taddr:" << tmp << endl;
            return tmp;
        }
        tmp = tmp->next;
    }
    cout << "Not find dat" << endl;
    return head;
}

uint32_t list::list_findcursor(uint16_t cnt){
    if(cnt >= get_list_len()){
        cout << "param error!!!" << endl;
        return 0;
    }
    pNode tmp = head;
    while(cnt--){
        tmp = tmp->next;
    }
    return tmp->data;
}
链表的节点替换

先判断替换的两个节点是否在该链表中，是否为同一个节点；
判断两个节点是否相邻；
节点处理咯

pNode list::list_changenode(pNode src_node, pNode des_node){
    pNode tmp = head->next;
    uint8_t flag = 0;
    cout << "\n\nsrc_node:" << src_node << "\tdes_node:" << des_node << endl;
    if(src_node == des_node){
        cout << "desNode equel desNode" << endl;
        return head;
    }
    while(tmp != head){
        if((tmp==src_node) || (tmp==des_node)){
            flag++;
        }
        tmp = tmp->next;
    }
    if(2 != flag){
        cout << "pNode param error" << endl;
        return head;
    }
    if(src_node->next == des_node){
        src_node->prev->next = src_node->next;
        src_node->next->prev = src_node->prev;

        src_node->next = des_node->next;
        src_node->prev = des_node;
        des_node->next->prev = src_node;
        des_node->next = src_node;
    }else if(des_node->next == src_node){
        des_node->prev->next = des_node->next;
        des_node->next->prev = des_node->prev;

        des_node->next = src_node->next;
        des_node->prev = src_node;
        src_node->next->prev = des_node;
        src_node->next = des_node;
    }else{
        pNode pSrc = src_node->prev;
        pNode pDes = des_node->prev;
        src_node->prev->next = src_node->next;
        src_node->next->prev = src_node->prev;

        src_node->next = pDes->next;
        src_node->prev = pDes;
        pDes->next->prev = src_node;
        pDes->next = src_node;

        des_node->prev->next = des_node->next;
        des_node->next->prev = des_node->prev;

        des_node->next = pSrc->next;
        des_node->prev = pSrc;
        pSrc->next->prev = des_node;
        pSrc->next = des_node;
    }
    return head;
}
链表的排序

一、根据链表中的数据进行升序排序，只交换值，节点不做更改；
二、根据链表中的数据进行升序排序，直接交换节点的位置。

pNode list::list_sortval(void){
    uint16_t len = get_list_len();
    for(uint16_t i=0;i<len-1;i++){
        for(uint16_t j=0;j<len-i-1;j++){
            if(list_findcursor(j) > list_findcursor(j+1)){
                uint32_t tmp = list_findcursor(j+1);
                list_changecursorval(j+1, list_findcursor(j));
                list_changecursorval(j, tmp);
            }
        }
    }
    return head;
}
pNode list::list_sortnode(void){
    uint16_t len = get_list_len();
    for(uint16_t i=0;i<len-1;i++){
        for(uint16_t j=0;j<len-i-1;j++){
            if(list_findcursor(j) > list_findcursor(j+1)){
                list_changenode(list_getnode(j), list_getnode(j+1));
            }
        }
    }
    return head;
}

该链表的功能函数较多，整体测试篇幅有限，所以进行功能性分块测试，有兴趣的也可以自行综合测试。

1.插入测试
int main(void){
    list L;
    uint16_t cnt = 0;
    uint16_t cursor = 0;
    uint32_t tmp = 0;
    cout << "Insert Node from head" << endl;
    cout << "How many Node need to insert" << endl;
    cin >> cnt;
    for(uint16_t i=0;i<cnt;i++){
        cin >> tmp;
        L.list_addhead(tmp);
    }
    L.list_print();
    L.get_list_len();

    cout << "\nInsert Node from tail" << endl;
    cout << "How many Node need to insert" << endl;
    cin >> cnt;
    for(uint16_t i=0;i<cnt;i++){
        cin >> tmp;
        L.list_addtail(tmp);
    }
    L.list_print();
    L.get_list_len();
}

在这里插入图片描述

2. 删除测试
int main(void){
    list L;
    uint16_t cnt = 0;
    uint16_t cursor = 0;
    uint32_t tmp = 0;
    cout << "Insert Node from head" << endl;
    cout << "How many Node need to insert" << endl;
    cin >> cnt;
    for(uint16_t i=0;i<cnt;i++){
        cin >> tmp;
        L.list_addhead(tmp);
    }
    L.list_print();
    L.get_list_len();
    
    cout << "\ndelete Node from head" << endl;
    cout << "How many Node need to delete" << endl;
    cin >> cnt;
    for(uint16_t i=0;i<cnt;i++){
        L.list_delhead();
    }
    L.list_print();
    L.get_list_len();

    cout << "\ndelete Node from tail" << endl;
    cout << "How many Node need to delete" << endl;
    cin >> cnt;
    for(uint16_t i=0;i<cnt;i++){
        L.list_deltail();
    }
    L.list_print();
    L.get_list_len();

    cout << "\ndelete Node from anywhere" << endl;
    cout << "How many Node need to delete" << endl;
    cin >> cnt;
    for(uint16_t i=0;i<cnt;i++){
        cin >> cursor;
        L.list_del(cursor);
    }
    L.list_print();
    L.get_list_len();
}

在这里插入图片描述

3.查找测试
int main(void){
    list L;
    uint16_t cnt = 0;
    uint16_t cursor = 0;
    uint32_t tmp = 0;
    cout << "Insert Node from head" << endl;
    cout << "How many Node need to insert" << endl;
    cin >> cnt;
    for(uint16_t i=0;i<cnt;i++){
        cin >> tmp;
        L.list_addhead(tmp);
    }
    L.list_print();
    L.get_list_len();

    cout << "\nfind function test" << "\nEnter the value to look for" << endl;
    cin >> tmp;
    L.list_findval(tmp);
    cin >> tmp;
    L.list_findval(tmp);

    cout << "\nEnter the cursor to look for" << endl;
    cin >> tmp;
    cout << "Get value:" << L.list_findcursor(tmp) << endl;
    cin >> tmp;
    cout << "Get value:" << L.list_findcursor(tmp) << endl;

    cout << "\nGet Node" << endl;
    cin >> cursor;
    L.list_getnode(cursor);
    cin >> cursor;
    L.list_getnode(cursor);
}

在这里插入图片描述

4.修改测试
int main(void){
    list L;
    uint16_t cnt = 0;
    uint16_t cursor = 0;
    uint32_t tmp = 0;
    uint32_t val = 0;
    cout << "Insert Node from head" << endl;
    cout << "How many Node need to insert" << endl;
    cin >> cnt;
    for(uint16_t i=0;i<cnt;i++){
        cin >> tmp;
        L.list_addhead(tmp);
    }
    L.list_print();
    L.get_list_len();

    cout << "\nchange function test" << "\nEnter the value to replace" << endl;
    cin >> tmp >> val;
    L.list_changeval(tmp, val);
    L.list_print();
    cin >> tmp >> val;
    L.list_changeval(tmp, val);
    L.list_print();

    cout << "\nEnter the value and coord to replace" << endl;
    cin >> cursor >> tmp;
    L.list_changecursorval(cursor, tmp);
    L.list_print();
    cin >> cursor >> tmp;
    L.list_changecursorval(cursor, tmp);
    L.list_print();

    cout << "\nChange Node" << endl;
    cin >> cnt >> cursor;
    L.list_changenode(L.list_getnode(cnt), L.list_getnode(cursor));
    L.list_print();
    cin >> cnt >> cursor;
    L.list_changenode(L.list_getnode(cnt), L.list_getnode(cursor));
    L.list_print();
}

把值进行替换
在这里插入图片描述
将第n个节点的值进行替换
在这里插入图片描述
将两个节点进行替换，包括节点的地址
在这里插入图片描述

5.链表排序测试
int main(void){
    list L;
    uint16_t cnt = 0;
    uint16_t cursor = 0;
    uint32_t tmp = 0;
    uint32_t val = 0;
    cout << "Insert Node from head" << endl;
    cout << "How many Node need to insert" << endl;
    cin >> cnt;
    for(uint16_t i=0;i<cnt;i++){
        cin >> tmp;
        L.list_addhead(tmp);
    }
    L.list_print();
    L.get_list_len();

    cout << "\nSort the list, Just sort value" << endl;
    L.list_sortval();
    L.list_print();

    L.list_clear();

    cout << "\nHow many Node need to insert" << endl;
    cin >> cnt;
    for(uint16_t i=0;i<cnt;i++){
        cin >> tmp;
        L.list_addhead(tmp);
    }
    L.list_print();
    L.get_list_len();
    cout << "\nSort the list" << endl;
    L.list_sortnode();
    L.list_print();
}

在这里插入图片描述

链表的增删改查排序等操作就完了
结合例程，大家可以试着用链表实现栈、队列、环形缓冲区、拆分链表、接合链表、链表的多种排序、判断链表是否有环、哈希链表等更复杂的数据结构和算法咯

6.综合测试

== 略 略略略==

slimmm
关注
专栏目录
C/C++学习路线总结与分享
dvlinker的技术专栏
10-07 9万+
C/C++学习路线总结与分享
双向循环链表C++实现（完整版）
YYC的专栏
03-29 8330
#include using namespace std; /* *节点类 */ struct DCNode { int data; DCNode * prior; DCNode * next; }; /* *链表类 */ struct DCList { DCList() { size = 0; } size_t size;//记录节点数的个数 DCNode * hea
C++实现双向循环链表
BeiXi's Blog
02-07 1608
本次博文是关于利用C++模板的方式实现的双向循环链表以及双向循环链表的基本操作，在之前的博文C++语言实现双向链表中，已经给大家分析了双向循环链表的结构，并以图示的方式给大家解释了双向循环链表的基本操作。本篇文章利用C++实现了双向循环链表的基本操作，其中包括： 双向循环链表 实现的功能 头部插入结点建立链表 尾部插入结点建立链表 实现指定位置插入结点 查找给定数值是否存在 ...
029. 排序的循环链表 C++
LB_AUTO的博客
10-08 439
029. 排序的循环链表 题目说明 给定循环升序列表中的一个点，写一个函数向这个列表中插入一个新元素 insertVal ，使这个列表仍然是循环升序的。 给定的可以是这个列表中任意一个顶点的指针，并不一定是这个列表中最小元素的指针。 如果有多个满足条件的插入位置，可以选择任意一个位置插入新的值，插入后整个列表仍然保持有序。 如果列表为空（给定的节点是 null），需要创建一个循环有序列表并返回这个节点。否则。请返回原先给定的节点。 示例 1： 输入：head = [3,4,1], insertVal =
c++实现双向链表类（增，删，改，查）
xifengshangui的博客
01-25 2201
前言 小猿根据实际需求，此次实现的是双向链表类，并附有详细的代码注释，双向链表是工作最实用的数据结构类型，和小猿一起学习吧。 一、链表的特点及和数组的区别 特点： 1、 链表是一种非连续的存储结构（相对于数组）。 2、 链表由一系列的结点组成，每个结点包括两个部分：数据和指针。 3、 链表通过结点中的指针来确定逻辑顺序。 区别： 1、 数组通过数组名字以及[]中的下标来访问数据，链表通过指针找到数据。 2、 数组无法动态增删元素（只能改），链表可以动态增、删、改结点。 3、 数组的定义、使用和回收空间操作简
C语言 链表的使用（链表的增删查改，链表逆转，链表排序）
weixin_33827965的博客
02-25 103
//链表的使用 #define _CRT_SECURE_NO_WARNINGS #include&lt;stdio.h&gt; #include&lt;stdlib.h&gt; #include&lt;string.h&gt; //定义链表结构体 struct LinkCode{ int num; char sname[50]; struct ...
C/C++链表增删改查排序操作
11-21
使用C++实现双向循环链表的增删改查排序等操作，可查看个人博客的【[数据结构和算法]C/C++双向循环链表实现(增删改查排序)】--链接https://blog.csdn.net/slimmm/article/details/84317806
关于双向链表的增删改查和排序的C++实现
08-31
以上就是关于双向链表的增删改查和排序的C++实现。双向链表的灵活性使其在处理需要双向遍历或频繁插入、删除操作的问题时特别有用。通过这个实现，我们可以高效地处理链表数据，进行各种操作，并能根据需求对其进行...
C++实现双向链表的增删改查与排序
本文档主要介绍了如何在C++中实现双向链表的数据结构，并提供了针对双向链表的基本操作，包括增删改查以及排序功能。双向链表是一种特殊类型的链表，每个节点包含两个指针，一个指向前一个节点（前驱），另一个指向...
双向循环链表C++实现
weixin_39472683的博客
06-28 375
#ifndef YITERATOR_H_ #define YITERATOR_H_ template<class T> //在外部自定义一个迭代器类 class yiterator { public: virtual void outputd(){ }; }; #endif /* YITERATOR_H_ */ #ifndef DCIRCULA...
双向循环链表 - C++实现
CC_且听风吟丶的博客
06-24 333
双向循环链表 抽象数据类型（ADT）大致如下： // 双向循环链表 typedef struct _DNode { int data; struct _DNode * pre; struct _DNode * next; }DNode; DNode * createDList(); void insertDList(DNode * head, int data); void trav...
C++实现的双向循环链表类
JUGG2014的博客
08-16 408
博客第一天 双向链表类CCircularNode.hclass CCircularNode { public: CCircularNode(CCircularNode &); CCircularNode() { lastNode = this; nextNode = this; } ~CCircularNode(); CC
用C++实现双链表的增删查改以及双向链表的逆转
zhuohaiyy的博客
07-27 1017
在我们实现双向链表的增删查改时一定要注意各种情况 分析各种情况我们才能更好的掌握增删查改以下是双向链表增删查改的代码。#include<iostream> #include<assert.h> #include<windows.h> using namespace std; typedef int DataType;struct ListNode { ListNode* _next;
双向循环链表（C++实现）
st66688的博客
09-22 3017
双向循环链表内容整理
循环双向链表（C++）
最新发布
weixin_53088153的博客
09-02 220
的循环双向链表c++实现。
C++ 双向循环链表（简称：双链表）
ChanJose的博客
01-04 1147
一、概念     1.在双链表中的每个结点应有两个链接指针：               lLink -&gt; 指向前驱结点  （前驱指针或者左链指针）               rLink-&gt;指向后继结点（后驱指针或者右链指针）       2.双链表常采用带附加头结点的循环链表方式：        first：头指针，不存放数据，或者存放特殊要求的数据。它的lLink指向...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值