C++数据结构第30课、双向链表的实现

最新推荐文章于 2022-03-31 14:42:01 发布
最新推荐文章于 2022-03-31 14:42:01 发布
阅读量121 收藏
点赞数
分类专栏： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xiebs/article/details/108028863
版权

1、交流的问题

在这里插入图片描述
2、单链表的另一个缺陷

— 单向性：只能从头结点开始高效访问链表中的数据元素

— 缺陷：如果需要逆向访问单链表中的数据元素将极其低效

在这里插入图片描述

3、新的线性表

设计思路：在“单链表”的结点中增加一个指针 pre，用于指向当前结点的前驱结点
在这里插入图片描述
双向链表的插入：

在这里插入图片描述

bool insert(int i, const T& e)
{
    bool ret = (0 <= i && i <= m_length);
    if(ret)
    {
        Node* node = create();
        if(node != nullptr)
        {
            Node* current = position(i);
            Node* next = current->next;

            node->value = e;
            node->next = next;
            current->next = node;

            if(current != reinterpret_cast<Node*>(&m_header))	//判断它不为头结点
            {
                node->pre = current;
            }
            else
            {
                node->pre = nullptr;
            }

            if(next != nullptr)		//判断它不为空
            {
                next->pre = node;
            }

            m_length++;
        }
        else
        {
            THROW_EXCEPTION(NoEnoughMemoryException, "No memory to insert LinkList");
        }
    }
    return ret;

}

双向链表的删除：

在这里插入图片描述

bool remove(int i)
{
    bool ret = (0 <= i && i < m_length);
    if(ret)
    {
        Node* current = position(i);

        Node* toDel = current->next;

        Node* next = toDel->next;

        if(m_current == toDel)
        {
            m_current = next;
        }

        current->next = next;

        if(next != nullptr)
        {
            next->pre = current;
        }

        m_length--;
        destroy(toDel);

    }
    return ret;
}

4、双向链表的继承结构

在这里插入图片描述
在这里插入图片描述
程序：
DualLinkList.h

#ifndef DUALLINKLIST_H
#define DUALLINKLIST_H

#include "List.h"
#include "Exception.h"

namespace XiebsLib
{

template <typename T>
class DualLinkList : public List<T>
{
protected:
    struct Node : public Object
    {
        T value;
        Node* next;
        Node* pre;
    };

    //mutable Node m_header;

    mutable struct : public Object
    {
        char reserved[sizeof(T)];
        Node* next;
        Node* pre;
    }m_header;

    int m_length;
    Node* m_current;
    int m_step;

    Node* position(int i)const
    {
        Node* ret = reinterpret_cast<Node*>(&m_header);
        for(int p = 0; p < i; p++)
        {
            ret = ret->next;
        }
        return ret;
    }

    virtual Node* create()
    {
        return new Node;
    }

    virtual void destroy(Node* pn)
    {
        delete pn;
    }

public:
    DualLinkList()
    {
        m_header.next = nullptr;
        m_header.pre = nullptr;
        m_length = 0;

        m_current = nullptr;
        m_step = 1;
    }

    virtual bool move(int i, int step = 1)
    {
        bool ret = (0 <= i && i < m_length && step > 0);
        if(ret)
        {
            m_current = position(i)->next;
            m_step = step;
        }
        return ret;
    }

    virtual bool end()
    {
        return (m_current == nullptr);
    }

    virtual bool next()
    {
        int i = 0;
        while(i < m_step && !end())
        {
            m_current = m_current->next;
            i++;
        }
        return (i == m_step);
    }

    virtual bool pre()
    {
        int i = 0;
        while(i < m_step && !end())
        {
            m_current = m_current->pre;
            i++;
        }
        return (i == m_step);
    }

    virtual T current()
    {
        if(!end())
        {
            return m_current->value;
        }
        else
        {
            THROW_EXCEPTION(InvalidOperationException, "No value at current Position");
        }

    }

    bool insert(int i, const T& e)
    {
        bool ret = (0 <= i && i <= m_length);
        if(ret)
        {
            Node* node = create();
            if(node != nullptr)
            {
                Node* current = position(i);
                Node* next = current->next;

                node->value = e;
                node->next = next;
                current->next = node;

                if(current != reinterpret_cast<Node*>(&m_header))
                {
                    node->pre = current;
                }
                else
                {
                    node->pre = nullptr;
                }

                if(next != nullptr)
                {
                    next->pre = node;
                }

                m_length++;
            }
            else
            {
                THROW_EXCEPTION(NoEnoughMemoryException, "No memory to insert LinkList");
            }
        }
        return ret;

    }

    bool insert(const T& e)
    {
        return insert(m_length, e);
    }

    bool remove(int i)
    {
        bool ret = (0 <= i && i < m_length);
        if(ret)
        {
            Node* current = position(i);

            Node* toDel = current->next;

            Node* next = toDel->next;

            if(m_current == toDel)
            {
                m_current = next;
            }

            current->next = next;

            if(next != nullptr)
            {
                next->pre = current;
            }

            m_length--;
            destroy(toDel);

        }
        return ret;
    }

    bool set(int i, const T& e)
    {
        bool ret = (0 <= i && i < m_length);
        if(ret)
        {
            position(i)->next->value = e;
        }
        return ret;
    }

    bool get(int i, T& e)const
    {
        bool ret = (0 <= i && i < m_length);
        if(ret)
        {
            e = position(i)->next->value;
        }
        return ret;
    }

    virtual T get(int i)
    {
        T ret;
        if(get(i, ret))
        {
            return ret;
        }
        else
        {
            THROW_EXCEPTION(IndexOutOfBoundsException, "Parameter i is Invalid");
        }
    }

    int find(const T& e)const
    {
        int ret = -1;
        int i = 0;
        Node* node = m_header.next;
        while(node != nullptr)
        {
            if(node->value == e)
            {
                ret = i;
                break;
            }
            else
            {
                node = node->next;
                i++;
            }
        }
        return ret;
    }

    int length()const
    {
        return m_length;
    }


    void clear()
    {
        while(m_length > 0)
        {
            remove(0);
        }
    }

    ~DualLinkList()
    {
        clear();
    }
};
}
#endif // DUALLINKLIST_H

main.cpp

#include <iostream>
#include "DualLinkList.h"
#include "Exception.h"

using namespace std;
using namespace XiebsLib;


int main()
{
    DualLinkList<int> dl;

    for(int i = 0; i < 5; i++)
    {
        dl.insert(0, i);
        dl.insert(0, 5);
    }

    for(dl.move(0); !dl.end(); dl.next())
    {
        cout << dl.current() << endl;
    }

    cout << "begin" << endl;
//    for(dl.move(dl.length()-1); !dl.end(); dl.pre())
//    {
//        cout << dl.current() << endl;
//    }

    dl.move(dl.length()-1);
    while (!dl.end())
    {
        if(dl.current() == 5)
        {
            cout << dl.current() << endl;
            dl.remove(dl.find(dl.current()));
        }
        else
        {
            dl.pre();
        }
    }

    cout << "end" << endl;

    for(dl.move(0); !dl.end(); dl.next())
    {
        cout << dl.current() << endl;
    }
    return 0;
}

在这里插入图片描述

小结
— 双向链表是为了弥补单链表的缺陷而重新设计的
— 在概念上，双向链表不是单链表，没有继承关系
— 双向链表中的游标能够直接访问当前结点的前驱和后继
— 双向链表是线性表概念的最终实现（更贴近理论的线性表）

在这里插入图片描述
在这里插入图片描述

xiebs_
关注
专栏目录
数据结构与算法详解——链表篇（附c++实现代码）
JMasker的博客
05-01 3214
链表详解及完整实现
数组、单链表和双链表介绍以及双向链表的C/C++实现
SB202211的博客
07-19 783
节点10"的后继节点是"节点20"(数据为10的节点)，"节点20"的前继节点是"节点10"；表头为空，表头的后继节点是"节点10"(数据为10的节点)，"节点10"的后继节点是"节点20"(数据为10的节点)，..."节点20"的后继节点为"节点30"，而"节点30"的后继节点为"节点40"。"节点10"的后继节点为"节点15"，而"节点15"的后继节点为"节点20"。"节点10"的后继节点为"节点20"，"节点20"的前继节点为"节点10"。"节点10"的后继节点为"节点20"。......
C++数据结构之双向链表
weixin_44568899的博客
10-19 210
#ifndef DLIST_H_INCLUDED #define DLIST_H_INCLUDED #include<iostream> using namespace std; template <class T> struct dListNode { T data; dListNode<T> *prior; dListNode&...
C++数据结构与算法之双向链表
Layne的专栏
11-26 221
链表中的每个节点有两个指针，一个指向前驱，一个指向后继，这种链表称为双向链表。 下图是双向链表，把这个图形记牢了，后续的删除等操作都需要去画一画才能更好的理解。 genDLList.h #ifndef STRUCTURE_GENDLLIST_H #define STRUCTURE_GENDLLIST_H template<class T> class DLLNod...
C++数据结构之双向链表(十九)
杨杨子江的博客
10-24 181
引用了猎豹网校的教程 main.cpp #include <iostream> #include "List.h" using namespace std; int main() { List<int> myList; myList.push_front(20); myList.push_front(30); myList.push_back(10); ...
算法与数据结构【C++】：双向链表
WilliamCode的博客
01-26 299
双向链表相对于单向链表的优点： 1、单向链表在需要对列表尾部进行操作时，需要通过遍历的方式获取尾部的结点，很浪费时间 2、对于需要频繁使用deleteFromTail()和addToTail()方法的程序，程序效率会非常低 3、双向链表存储了每个结点前面的结点，在对尾部进行操作时，能非常方便的获取尾部的结点信息，方便对尾部进行操作，大大提高了程序效率 4、但是，...
数组、单链表和双链表介绍以及双向链表的CC++Java实现 数组和链表.pdf
04-18
数组、单链表和双链表介绍以及双向链表的C、C++和Java实现 在计算机科学中，数组、单链表和双链表是...双向链表的实现可以使用C、C++和Java三种语言，它们的实现方式也有所不同，但是它们都可以实现双链表的基本操作。
数据结构实验一 用链表实现大整数加减法
m0_61506053的博客
03-31 4131
题目： 用链表实现大整数加减法操作： 32位机器直接操作的数据最大为32个bit，若超过32bit，则需要单独设计算法。在这里，可以用链表每个结点存储大整数的每一位的十进制数字，则可以进行大整数的算数运算，该实验仅实现加减法操作。 要求: 随机产生2个1~50位的数字串，并存储到2个链表中。 进行加法或减法操作，结果存储到新的链表中。 打印运算结果。 目录 BigInteger.h BigInteger.cpp function.h function.cpp main.cpp ..
数据结构 ——c++实现（知识点集合）
Ang_go的博客
03-18 1588
数据结构 ——c++实现（知识点集合） 某不知名学狗的复习记录，包含数据结构基本概念，线性表，栈、队列、递归，串、数组、广义表和树和森林内容整理。主要整理了知识点，代码较少。 第一章 绪论 1.1（算法+数据结构） = 程序 这个括号是体现面向对象的观点 1.2 数据结构的基本概念 数据结构的定义 数据，是信息的载体，是描述客观事物的数、字符、图形、图像、声音以及所有能输入计算机中并被计算机程序是别的和处理的符号的集合。 数据在特定的情况下可以是数字，或者是字符，数据对象就是数据的子集。例如一个特定的，
【C/C++】【数据结构】双向链表操作
乞木的博客
08-07 1238
目录 双向链表操作 头文件定义 双向链表的初始化 双向链表的插入  双线链表求链表长度 双向链表的判空 双向链表的遍历  双向链表的查找（通过位置求值） 双向链表的检索（通过值求位置） 双向链表的删除  双向链表的重置 双向链表的销毁 测试文件 双向链表操作 像双向链表的求长，判空，遍历，查找，检索，之类的操作都和单链表一样的。不过我还是在了文中。 头文件定义 ...
C++数据结构--双向链表
海到无边天作岸 山登绝顶我为峰
04-07 2236
测试代码 #include <iostream> #include <iomanip> using namespace std; template <class DataType> struct DulNode { DataType data; DulNode <DataType>*prior,*next; }; template <cla...
数据结构—双链表（C/C++版）
coder_gxd的博客
04-05 492
本文为CSDN博主coder_gxd原创转载请注明：https://blog.csdn.net/coder_gxd/article/details/79828377本文介绍数据结构中双链表的常用算法（C/C++版），欢迎各位同学讨论指正。#include &lt;stdlib.h&gt;//函数malloc(),free()所在头文件 //本文双链表均为含有头结点的双链表 //双链表结点的定义...
数据结构双向链表C++实现
Clown_pan的博客
05-22 856
#include <iostream> #include <stdio.h> #include <stdlib.h> #define OVERFLOW -3 #define true 1 #define false 0 #define ok 1 #define error -1 using namespace std; typedef struct DuLNo...
C++实现双向链表
热门推荐
久久乐
07-10 2万+
下面就是我们双向链表的基本原理。这里我们插入代码案例：头文件DoubleLink.h#ifndef DOUBLE_LINK_HXX #define DOUBLE_LINK_HXX #include &lt;iostream&gt; using namespace std; //一个节点 template&lt;class T&gt; struct DNode { public: T val...
数据结构-双向链表(c++)超全超详细
Abieai的博客
12-01 1万+
文章目录前言一、双向链表是什么？二、双向链表上的基本操作1.定义双向链表2.初始化双链表3.前插法创建双链表4.尾插法创建双链表5.双向链表的遍历输出6.双链表的指定位置插入7.双链表的按位取值8.双链表的任意位置删除9.双链表的销毁三、全部代码(主函数部分比较凌乱）总结 前言 单链表结点中只有一个指向其后继的指针，使得单链表只能从头结点依次顺序地向后遍历。要访问某个结点的前驱结点（插入，删除操作时），只能从头开始遍历，访问后继结点的时间复杂度为O(1)，访问前驱结点的时间复杂度为O(n)。 提示：以.
C++数据结构第63课、二叉树中的结点插入操作
xiebs的博客
08-27 2040
我们在进行插入操作的时候不是二叉树的任意结点都能插入，必须得指明插入新结点的位置，是左子树还是右子树，如果不指明便是默认从左向右的进行插入。 因此我们得定义一个枚举，用来表示二叉树结点的位置。 插入操作分为两种： — 插入新结点 bool insert(TreeNode<T>* node) bool insert(TreeNode<T>* node, BTNodePos pos) — 插入数据元素 bool insert(const T& value, TreeNode..
C++数据结构第24课、单链表的遍历和优化
xiebs的博客
07-02 1158
问题 如何遍历单链表中的每一个数据元素 当前单链表的遍历方法 LinkList<int> list; for(int i = 0;i < 5;i++) { list.insert(0, i); } for(int i = 0;i < list.length();i++) { cout << list.get(i) << endl; } 遗憾的是：我们不能以线性的时间复.
C++第四版：数据结构与算法详解——从基础到应用
第三章详细介绍了链接列表，特别是通过指针实现的不同类型，如单链表、双向链表等，这些是基础的数据结构，对于实现动态数据管理至关重要。 第四个章节深入剖析栈和队列，它们在数据处理和程序设计中有广泛应用，如...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值