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

随机推荐

[刷题] PTA 03-树1 树的同构
程序: 1 #include <stdio.h> 2 #define MaxTree 10 3 #define ElementType char 4 #define Tree int 5 ...
C++知识点案例笔记-4
1.纯虚函数 2.抽象类 3.内部类 4.运算符重载 5.类的函数重载 6.友元的函数重载 1.纯虚函数 ==纯虚函数== //有时基类中无法给出函数的具体体现,定义纯虚函数可以为派生函数保留一个函数 ...
IT菜鸟之虚拟机VMware的使用
虚拟机安装完成了,以下是虚拟机的使用. 双击快捷方式,打开vmware虚拟机. 点击创建新虚拟机,这里可以选择创建方式,可以点击典型并一路下一步创建,我们这里讲自定义创建. 这里选择兼容版本,大家可以 ...
lsscsi
# lsscsi[2:0:0:0] cd/dvd Slimtype DVD A DS8ACSH LC2M /dev/sr0[3:0:0:0] disk ATA Samsung SSD 860 3B6Q ...
【转-备忘】scatter函数
1.scatter函数原型 2.其中散点的形状参数marker如下: 3.其中颜色参数c如下: 4.基本的使用方法如下: #导入必要的模块 import numpy as np import matp ...
gpgj-19.高级课总结
19.高级课总结 1.高级课最终站如何对公司估值找到公司未来的真实盈利*回本年限=估值如何计算公司未来的盈利 ROIC 资本回报率零售公司每平米净现金流经营面积高速公路每 ...
IDEA 创建 Vue 文件（Day_41）
IDEA 创建 Vue 文件 1. 在setting-->plugins里安装vue插件,安装成功之后重启IDEA 如图 2. 在setting-->Editor-->File Ty ...
某SPI设备驱动引起的开关机压力测试死机问题一例
环境硬件平台:某ARM SoC 软件平台:Linux 问题现象:产品做开关机压力测试,发生死机. 分析用crash工具解析两次死机dump信息,得到死机前的log如下.两次死机的backtrace ...
CefSharp如何进行页面的缩放（即Ctrl+滚轮）
问题:CefSharp如何进行页面的缩放摘要:由于CefSharp并没有提供鼠标滚轮事件.只有一个KeyboardHandler事件,因此只能接收到键盘事件. 环境:CefShap.Wpf 了解Ce ...
Step By Step(Lua数据结构)
Step By Step(Lua数据结构) Lua中的table不是一种简单的数据结构,它可以作为其它数据结构的基础.如数组.记录.线性表.队列和集合等,在Lua中都可以通过table来表示. ...

双向链表（DoubleLinkList）

双向链表

添加

头添加

指定节点添加

尾添加

删除

头删除

指定节点删除

尾删除

头尾指针版

虚拟头节点

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

随机推荐

热门专题