双向链表（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 ...

随机推荐

[DB] Flink 读 MySQL
思路在 Flink 中创建一张表有两种方法: 从一个文件中导入表结构(Structure)(常用于批计算)(静态) 从 DataStream 或者 DataSet 转换成 Table (动态) pa ...
[bug] Linux下执行.sh命令出现-bash: ./bin/start.sh: /bin/bash^M: bad interpreter: No such file or directory
参考 https://www.cnblogs.com/aeolian/p/10614284.html
Jmeter 设置中文
1.正常启动jmeter.bat 2.点击[Options]选项,弹出下拉菜单选择[Choose Language]选项3.选择[Choose Language]选项,弹出下一级菜单选择[Chines ...
commit信息修改
场景:向社区提交commit信息,code reviewer给你回复说,请添加TrivialFix并且完善commit信息.好吧,虽然这对代码的运行无关紧要,但是对于日后的代码管理是很有必要的. 解决 ...
利用jink的驱动软件j-flash 合并两个hex的方法，bootloader+app -(转载)
第一步:先打开第一个hex文件, 第二步:选择 "Merge data file",合并文件第三步:两个工程有可能地址相同,会有如下提示:(如果在编译的时候设置好Flash的地址 ...
云计算OpenStack---维护及错误排查（13）
错误一:删除僵尸卷在openstack dashboard中正常删除实例,未删除卷,然后重启了服务器,出现BUG,卷被附加给了'NONE',并且无法删除,无法更新. 既然log中已经提示无法删除卷的 ...
mysql基础之帮助信息
在mysql中获取帮助 1.当连接到mysql数据库以后,使用help命令或者\?表示获取帮助信息: MariaDB [ren]> help General information about ...
linux route命令的使用详解-(转自小C爱学习)
route命令用于显示和操作IP路由表.要实现两个不同的子网之间的通信,需要一台连接两个网络的路由器,或者同时位于两个网络的网关来实现.在Linux系统中,设置路由通常是为了解决以下问题:该Linu ...
python 如何让俩个对象相等及如何让俩个对象具有相同的id值
Docker之tomcat安装与部署项目
docker安装tomcat docker pull tomcat:8.5 等待... (1)正常的方式启动tomcat docker run -d --name tomcat -p 80:808 ...

双向链表（DoubleLinkList）

双向链表

添加

头添加

指定节点添加

尾添加

删除

头删除

指定节点删除

尾删除

头尾指针版

虚拟头节点

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

随机推荐

热门专题