双向链表（DoubleLinkList）

双向链表

有关链表的知识可以点击我上篇文章这里就不再赘述LinkedList

双向链表也叫双链表，是链表的一种，它的每个数据结点中都有两个指针，分别指向直接后继和直接前驱。所以，从双向链表中的任意一个结点开始，都可以很方便地访问它的前驱结点和后继结点。一般我们都构造双向循环链表。

双向循环链表的可以点击我这篇文章这里就不再赘述DoubleLoopLinkList

添加

头添加

void addFirst(const T &e) {

	//新建一个节点让它前驱指向头，后继指向头的后继然后再让头的后继指向新建的节点，

        head->next = new Node<T>(e, head, head->next);

        //把新节点的后继节点的前驱指向新节点

        head->next->next->prev = head->next;

        ++size;

}

指定节点添加

void add(const int index, const T &e) {

        assert(index >= 0 && index <= size);

        Node<T> *prevNode = head;

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

            prevNode = prevNode->next;

        }

        prevNode->next = new Node<T>(e, prevNode, prevNode->next);

        prevNode->next->next->prev = prevNode->next;

        ++size;

    }

尾添加

void addLast(const T &e) {

		//

        tail->prev = new Node<T>(e, tail->prev, tail);

        tail->prev->prev->next = tail->prev;

        ++size;

}

删除

头删除

 T removeFirst() {

        return remove(0);//调不调都是O(1)，就这吧。

    }

指定节点删除

T remove(int index) {

        assert(index >= 0 && index < size);

        //找到待删除节点的前一节点

        Node<T> *prevNode = head;

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

            prevNode = prevNode->next;

        }

        //暂存要删除的节点

        Node<T> *retNode = prevNode->next;

        T temp = retNode->e;

        //前一节点的后继指向待删除节点的后继

        prevNode->next = retNode->next;

        //后一节点的前驱指向待删除节点的前驱

        retNode->next->prev = retNode->prev;

        retNode->next = nullptr;

        retNode->prev = nullptr;

        --size;

        delete retNode;

        retNode = nullptr;

        return temp;

    }

尾删除

T removeLast() {

	//先暂存要删除的节点

    Node<T> *retNode = tail->prev;

    T temp = retNode->e;

    //尾指针的前驱指向待删除的前驱

    tail->prev = retNode->prev;

    待删除节点前面一节点的后继指向尾指针

    retNode->prev->next = tail;

    retNode->next = nullptr;

    retNode->prev = nullptr;

    delete retNode;

    retNode = nullptr;

    --size;

    return temp;

}

头尾指针版

//

// Created by cheng on 2021/7/5.

//

#ifndef LINKEDLIST_TEST_H

#define LINKEDLIST_TEST_H

#include <assert.h>

template<typename T>

class Node {

public:

    T e;

    Node *prev;

    Node *next;

    Node() : e(0), prev(nullptr), next(nullptr) {

    }

    Node(const T &E) : e(E), prev(nullptr), next(nullptr) {

    }

    Node(const T &E, Node<T> *Prev, Node<T> *Next) : e(E), prev(Prev), next(Next) {

    }

};

template<typename T>

class DoubleLinkedList {

public:

    DoubleLinkedList() : size(0) {

        head = new Node<T>(0, nullptr, head);

        tail = new Node<T>(0, tail, nullptr);

    }

    constexpr int getSize() const {

        return size;

    }

    constexpr bool isEmpty() const {

        return size == 0;

    }

    void add(const int index, const T &e) {

        assert(index >= 0 && index <= size);

        Node<T> *prevNode = head;

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

            prevNode = prevNode->next;

        }

        prevNode->next = new Node<T>(e, prevNode, prevNode->next);

        prevNode->next->next->prev = prevNode->next;

        ++size;

    }

    void addFirst(const T &e) {

        head->next = new Node<T>(e, head, head->next);

        head->next->next->prev = head->next;

        ++size;

    }

    void addLast(const T &e) {

        tail->prev = new Node<T>(e, tail->prev, tail);

        tail->prev->prev->next = tail->prev;

        ++size;

    }

    void set(const int index, const T &e) {

        assert(index >= 0 && index < size);

        Node<T> *cur = head->next;

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

            cur = cur->next;

        }

        cur->e = e;

    }

    void setFirst(const T &e) {

        head->next->e = e;

    }

    void setLast(const T &e) {

        tail->prev->e = e;

    }

    bool contains(const T &e) const {

        Node<T> *cur = head->next;

        while (cur != nullptr) {

            if (cur->e = e) {

                return true;

            }

            cur = cur->next;

        }

        return false;

    }

    T get(const int index) const {

        assert(index >= 0 && index < size);

        Node<T> *cur = head->next;

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

            cur = cur->next;

        }

        return cur->e;

    }

    T getFirst() const {

        return head->next->e;

    }

    T getLast() const {

        return tail->prev->e;

    }

    T remove(int index) {

        assert(index >= 0 && index < size);

        Node<T> *prevNode = head;

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

            prevNode = prevNode->next;

        }

        Node<T> *retNode = prevNode->next;

        prevNode->next = retNode->next;

        retNode->next->prev = retNode->prev;

        retNode->next = nullptr;

        retNode->prev = nullptr;

        --size;

        T temp = retNode->e;

        delete retNode;

        retNode = nullptr;

        return temp;

    }

    T removeFirst() {

        return remove(0);

    }

    T removeLast() {

        Node<T> *retNode = tail->prev;

        T temp = retNode->e;

        tail->prev = retNode->prev;

        retNode->prev->next = tail;

        retNode->next = nullptr;

        retNode->prev = nullptr;

        delete retNode;

        retNode = nullptr;

        --size;

        return temp;

    }

    ~DoubleLinkedList() {

        Node<T> *cur = head->next;

        Node<T> *temp;

        while (cur != nullptr) {

            temp = cur->next;

            delete cur;

            cur = temp;

        }

        head->next = nullptr;

        head->prev = nullptr;

        tail->prev = nullptr;

        tail->next = nullptr;

        delete head;

        head = nullptr;

        delete tail;

        tail = nullptr;

    }

    void print() {

        Node<T> *prevNode = head;

        std::cout << "LinkedList: size = " << size << std::endl;

        std::cout << "[";

        for (int i = 0; i < size; ++i) {

            prevNode = prevNode->next;

            std::cout << prevNode->e;

            if (i < size - 1) {

                std::cout << ", ";

            }

        }

        std::cout << "]" << std::endl;

    }

private:

    Node<T> *head, *tail;

    int size;

};

#endif //LINKEDLIST_TEST_H

虚拟头节点

//

// Created by cheng on 2021/7/5.

//

#ifndef LINKEDLIST_DOUBLELINKEDLIST_H

#define LINKEDLIST_DOUBLELINKEDLIST_H

#include <assert.h>

template<typename T>

class Node {

public:

    T e;

    Node *prev;

    Node *next;

    Node() : e(0), prev(nullptr), next(nullptr) {}

    Node(const T &E) : e(E), prev(nullptr), next(nullptr) {}

    Node(const T &E, Node<T> *Prev, Node<T> *Next) : e(E), prev(Prev), next(Next) {}

};

template<typename T>

class DoubleLinkedList {

public:

    DoubleLinkedList() : size(0) {

        dummyHead = new Node<T>(0, nullptr, dummyHead);

    }

    constexpr int getSize() const {

        return size;

    }

    constexpr bool isEmpty() const {

        return size == 0;

    }

    void add(const int index, const T &e) {

        assert(index >= 0 && index <= size);

        Node<T> *prevNode = dummyHead;

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

            prevNode = prevNode->next;

        }

        prevNode->next = new Node<T>(e, prevNode, prevNode->next);

        prevNode->next->next->prev = prevNode->next;

        ++size;

    }

    void addFirst(const T &e) {

        add(0, e);

    }

    void addLast(const T &e) {

        add(size, e);

    }

    void set(const int index, const T &e) {

        assert(index >= 0 && index < size);

        Node<T> *cur = dummyHead->next;

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

            cur = cur->next;

        }

        cur->e = e;

    }

    void setFirst(const T &e) {

        set(0, e);

    }

    void setLast(const T &e) {

        set(size, e);

    }

    bool contains(const T &e) const {

        Node<T> *cur = dummyHead->next;

        while (cur != nullptr) {

            if (cur->e = e) {

                return true;

            }

            cur = cur->next;

        }

        return false;

    }

    T get(const int index) const {

        assert(index >= 0 && index < size);

        Node<T> *cur = dummyHead->next;

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

            cur = cur->next;

        }

        return cur->e;

    }

    T getFirst() const {

        return get(0);

    }

    T getLast() const {

        return get(size - 1);

    }

    T remove(int index) {

        assert(index >= 0 && index < size);

        Node<T> *prevNode = dummyHead;

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

            prevNode = prevNode->next;

        }

        Node<T> *retNode = prevNode->next;

        prevNode->next = retNode->next;

        retNode->next->prev = retNode->prev;

        retNode->next = nullptr;

        retNode->prev = nullptr;

        --size;

        T temp = retNode->e;

        delete retNode;

        retNode = nullptr;

        return temp;

    }

    T removeFirst() {

        return remove(0);

    }

    T removeLast() {

        return remove(size - 1);

    }

    ~DoubleLinkedList() {

        Node<T> *cur = dummyHead->next;

        Node<T> *temp;

        while (cur != nullptr) {

            temp = cur->next;

            delete cur;

            cur = temp;

        }

        dummyHead->next = nullptr;

        dummyHead->prev = nullptr;

        delete dummyHead;

        dummyHead = nullptr;

    }

    void print() {

        Node<T> *prevNode = dummyHead;

        std::cout << "LinkedList: size = " << size << std::endl;

        std::cout << "[";

        for (int i = 0; i < size; ++i) {

            prevNode = prevNode->next;

            std::cout << prevNode->e;

            if (i < size - 1) {

                std::cout << ", ";

            }

        }

        std::cout << "]" << std::endl;

    }

private:

    Node<T> *dummyHead;

    int size;

};

#endif //LINKEDLIST_DOUBLELINKEDLIST_H

双向链表（DoubleLinkList）的更多相关文章

java实现双向链表的增删改查
双向链表的增删改查和单链表的操作很像:https://blog.csdn.net/weixin_43304253/article/details/119758276 基本结构 1.增加操作 1.链接 ...
Java 数据结构之双向链表
一.概述: 1.什么是双向链表: 链表中的每个节点即指向前面一个节点,也指向后面一个节点,就像丢手绢游戏一样,每个人都手拉手 2.从头部插入要对链表进行判断,如果为空则设置尾节点为新添加的节点,如果 ...
c++ list双向链表管理对象
#cat list.cc #include <cstdlib> #include <iostream> #include <stdio.h> using names ...
python算法与数据结构-双向链表(40)
一.双向链表的介绍一种更复杂的链表是“双向链表”或“双面链表”.每个节点有两个链接:一个指向前一个节点,当此节点为第一个节点时,指向空值:而另一个指向下一个节点,当此节点为最后一个节点时,指向空值. ...
java数据结构——单链表、双端链表、双向链表（Linked List）
1.继续学习单链表,终于摆脱数组的魔爪了,单链表分为数据域(前突)和引用域(指针域)(后继),还有一个头结点(就好比一辆火车,我们只关心火车头,不关心其它车厢,只需知晓车头顺藤摸瓜即可),头结点没有前 ...
python实现双向链表的操作
双向链表双向链表又叫做双链表,每个节点有两个指针域和一个数据域.prev指针域指向前一个节点,next指针域指向下一个节点.注意,第一个节点的prev指针域指向空值,最后一个节点的next域也是指向 ...
双向链表——Java实现
双向链表链表是是一种重要的数据结构,有单链表和双向链表之分:本文我将重点阐述不带头结点的双向链表: 不带头结点的带链表我将对双链表的增加和删除元素操作进行如下解析 1.增加元素(采用尾插法) (1 ...
学习Redis你必须了解的数据结构——双向链表（JavaScript实现）
本文版权归博客园和作者吴双本人共同所有,转载和爬虫请注明原文链接 http://www.cnblogs.com/tdws/ 下午分享了JavaScript实现单向链表,晚上就来补充下双向链表吧.对链表 ...
双向链表、双向循环链表的JS实现
关于链表简介.单链表.单向循环链表.JS中的使用以及扩充方法: 单链表.循环链表的JS实现关于四种链表的完整封装: https://github.com/zhuwq585/Data-Structu ...

随机推荐

window 共享打印机
https://www.zhihu.com/question/20653708 https://h30471.www3.hp.com/t5/da-yin-ji-yu-sao-miao-yi-de-an ...
numpy tile()函数
tile(A,B)即在B的方向上,重复A 直接举栗子: A=[1,2] tile(A,2) 此时B=(2) ,B的方向仅包含列方向,将A在列方向上重复一次,得出结果如图1所示图1-将A在列方向重 ...
Docker的镜像理解以及容器的备份、恢复和迁移操作
Docker的镜像理解以及容器的备份.恢复和迁移操作这篇文章主要介绍了Docker的镜像理解以及容器的备份.恢复和迁移操作,覆盖很多原理知识以及容器的重要操作步骤,极力推荐!需要的朋友可以参考下 D ...
NLP文本分类
引言其实最近挺纠结的,有一点点焦虑,因为自己一直都期望往自然语言处理的方向发展,梦想成为一名NLP算法工程师,也正是我喜欢的事,而不是为了生存而工作.我觉得这也是我这辈子为数不多的剩下的可以自己去追 ...
Systemverilog MCDF寄存器描述
前三个寄存器是读写寄存器(控制寄存器) (一)地址0x00 :32bit bit[0]通道使能,1打开,0关闭.复位1. bit[2:1]优先级,0最高 bit[5:3]数据包长度,是解码对应的. 0 ...
JMicro微服务Hello World
概述 JMicro是本人开发的基于Java实现的微服务框架,前两天发布0.0.3正式版本,并已发布到maven中央仓库. 项目源码github:https://github.com/mynewworl ...
VMware vRealize Suite 8.3 发布 - 多云环境的云计算管理解决方案
概述 VMware vRealize Suite 是一种多云环境的云计算管理解决方案,为 IT 组织提供了一个基于 DevOps 和 ML 原则的基础架构自动化.一致运维和监管的现代平台. vReal ...
使用指定源安装python包
对于经常需要按照那个python包的同学,外网下载比较慢的话,可以使用公司内部的镜像进行安装 eg: pip install django -i http://mirrors.***.com.cn/p ...
最适合新手的Redis Cluster搭建过程
好记性不如烂笔头,记录分片高可用Redis Cluster的搭建过程 Redis集群演进过程 Redis单节点主从复制: 复制主要实现了数据的多机备份,以及对于读操作的负载均衡和简单的故障恢复. 故 ...
GO学习-(24) Go语言操作Redis
Go语言操作Redis 在项目开发中redis的使用也比较频繁,本文介绍了Go语言中go-redis库的基本使用. Redis介绍 Redis是一个开源的内存数据库,Redis提供了多种不同类型的数据 ...

双向链表（DoubleLinkList）

双向链表

添加

头添加

指定节点添加

尾添加

删除

头删除

指定节点删除

尾删除

头尾指针版

虚拟头节点

双向链表（DoubleLinkList）的更多相关文章

随机推荐

热门专题