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

随机推荐

mysql登录框注入绕过单引号匹配
0x00 原理网站使用正则匹配对用户名一栏传到服务器的参数进行了匹配,如果匹配到了单引号则报错 0x01 简单例子当我们输入admin'时,网站直接报错,很有可能就是用了正则,这样我们也不 ...
[刷题] 17 Letter Combinations of a Phone Number
要求给定一个仅包含数字 2-9 的字符串,返回所有它能表示的字母组合 1 不对应任何字母示例输入:"23" 输出:["ad", "ae&q ...
什么是环境变量，Linux环境变量及作用 echo
什么是环境变量,Linux环境变量及作用 < Linux命令的执行过程是怎样的?(新手必读)Linux PATH环境变量是什么,有什么用?(入门必读) > <Linux就该这么学&g ...
Zookeeper——Docker下安装部署
单节点安装一. 环境说明 docker: 18.09.9-ce zookeeper: 3.5.6 二. 拉取 zookeeper 镜像拉取镜像 docker pull zookeeper 默认是摘 ...
Linux上使用iSCSI概述
iSCSI简介 1. scsi和iscsi SCSI技术是存储设备最基本的标准协议,通常需要设备互相靠近并用SCSI总线连接,因此受到物理环境的限制 iSCSI(Internet Small Comp ...
Mysql数据库-多实例主从复制-主从故障详解
一.mysql结构 1.实例 1.什么是单实例一个进程 + 多个线程 + 一个预分配的内存空间 2.多实例多个进程 + 多个线程 + 多个预分配的内存空间 ](http://shelldon.51 ...
11.10 chkconfig：管理开机服务
chkconfig 命令是Redhat系列的Linux系统中的系统服务管理工具,它可以用于查询和更新不同的运行等级下系统服务的启动状态. chkconfig命令的参数选项及说明 --list 显 ...
centos7 搭建 nginx web服务反代理
Nginx("engine x")是一款是由俄罗斯的程序设计师Igor Sysoev所开发高性能的 Web和反向代理服务器,也是一个 IMAP/POP3/SMTP 代理服务器. ...
[leetcode] (周赛)868. 二进制间距
868. 二进制间距读懂题意就出来了 class Solution { public int binaryGap(int N) { String s = Integer.toBinaryString ...
SQL Parameter参数的用法
SqlParameter 类表示 SqlCommand 的参数,也可以是它到 DataSet 列的映射. 无法继承此类. 命名空间: System.Data.SqlClient 程序集: Sys ...

双向链表（DoubleLinkList）

双向链表

添加

头添加

指定节点添加

尾添加

删除

头删除

指定节点删除

尾删除

头尾指针版

虚拟头节点

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

随机推荐

热门专题