06-什么是双向链表----JavaScript数据结构与算法学习

最新推荐文章于 2024-03-20 19:19:13 发布
最新推荐文章于 2024-03-20 19:19:13 发布
阅读量153 收藏
点赞数
分类专栏： # 数据结构与算法，前端JavaScript学习
原文链接：https://www.jianshu.com/p/fb5a4169a618
版权

一. 认识双向链表

双向链表介绍

  • 单向链表:

    • 只能从头遍历到尾或者从尾遍历到头(一般从头到尾)
    • 也就是链表相连的过程是单向的. 实现的原理是上一个链表中有一个指向下一个的引用.
    • 单向链表有一个比较明显的缺点:
      • 我们可以轻松的到达下一个节点, 但是回到钱一个节点是很难的. 但是, 在实际开发中, 经常会遇到需要回到上一个节点的情况
      • 举个例子: 假设一个文本编辑用链表来存储文本. 每一行用一个String对象存储在链表的一个节点中. 当编辑器用户向下移动光标时, 链表直接操作到下一个节点即可. 但是当用于将光标向上移动呢? 这个时候为了回到上一个节点, 我们可能需要从first开始, 依次走到想要的节点上.

  • 双向链表

    • 既可以从头遍历到尾, 又可以从尾遍历到头
    • 也就是链表相连的过程是双向的. 那么它的实现原理, 你能猜到吗?
    • 一个节点既有向前连接的引用, 也有一个向后连接的引用.
    • 双向链表可以有效的解决单向链表中提到的问题.
    • 双向链表有什么缺点呢?
      • 每次在插入或删除某个节点时, 需要处理四个节点的引用, 而不是两个. 也就是实现起来要困难一些
      • 并且相当于单向链表, 必然占用内存空间更大一些.
      • 但是这些缺点和我们使用起来的方便程度相比, 是微不足道的.

  • 双向连接的图解:

    img

    img

双向链表的创建

  • 我们来创建一个双向链表的类

    // 创建双向链表的构造函数
function DoublyLinkedList() {
    // 创建节点构造函数
    function Node(element) {
        this.element = element
        this.next = null
        this.prev = null // 新添加的
    }

    // 定义属性
    this.length = 0
    this.head = null
    this.tail = null // 新添加的

    // 定义相关操作方法
}

  • 代码解析:

    • 基本思路和单向链表比较相似, 都是创建节点结构函数以及定义一些属性和方法.
    • 只是Node中添加了一个this.prev属性, 该属性用于指向上一个节点.
    • 另外属性中添加了一个this.tail属性, 该属性指向末尾的节点

二. 操作双向链表

双向链表的操作和单向链表的方法都是类似的.

只是在实现的过程中, 需要考虑更多节点之间的关系, 所以变得比单向链表复杂了一些.

尾部追加数据

  • 我们还是先来实现尾部追加数据的方法

    // 在尾部追加数据
DoublyLinkedList.prototype.append = function (element) {
    // 1.根据元素创建节点
    var newNode = new Node(element)

    // 2.判断列表是否为空列表
    if (this.head == null) {
        this.head = newNode
        this.tail = newNode
    } else {
        this.tail.next = newNode
        newNode.prev = this.tail
        this.tail = newNode
    }
    
    // 3.length+1
    this.length++
}

  • 代码解析:

    • 代码1部分不用多讲, 还是通过元素创建新的节点.
    • 代码2部分相比之前有一些复杂, 但是还是两种情况.
    • 情况一: 链表原来为空
      • 链表中原来如果没有数据, 那么直接让head和tail指向这个新的节点即可.
    • 情况二: 链表中已经存在数据
      • 因为我们是要将数据默认追加到尾部, 所以这个变得也很简单.
      • 首先tail中的next之前指向的是null. 现在应该指向新的节点newNode: this.tail.next = newNode
      • 因为是双向链表, 新节点的next/tail目前都是null. 但是作为最后一个节点, 需要有一个指向前一个节点的引用. 所以这里我们需要newNode.prev = this.tail
      • 因为目前newNod已经变成了最后的节点, 所以this.tail属性的引用应该指向最后: this.tail = newNode即可
    • 代码3部分不用多做解析, length需要+1
正向反向遍历

  • 链表的遍历

    • 之前我们在单向链表中实现了一个toString方法, 它是一种正向的遍历.
    • 现在, 为了用户使用方便, 我们实现三个方法
      • forwardString: 正向遍历转成字符串的方法
      • reverseString: 反向遍历转成字符串的方法
      • toString: 正向遍历转成字符串的方法

  • 方法的相关实现:

    // 正向遍历的方法
DoublyLinkedList.prototype.forwardString = function () {
    var current = this.head
    var forwardStr = ""
    
    while (current) {
        forwardStr += "," + current.element
        current = current.next
    }
    
    return forwardStr.slice(1)
}

// 反向遍历的方法
DoublyLinkedList.prototype.reverseString = function () {
    var current = this.tail
    var reverseStr = ""
    
    while (current) {
        reverseStr += "," + current.element
        current = current.prev
    }
    
    return reverseStr.slice(1)
}

// 实现toString方法
DoublyLinkedList.prototype.toString = function () {
    return this.forwardString()
}

  • 完成上面的代码后, 测试append方法

    // 1.创建双向链表对象
var list = new DoublyLinkedList()

// 2.追加元素
list.append("abc")
list.append("cba")
list.append("nba")
list.append("mba")

// 3.获取所有的遍历结果
alert(list.forwardString()) // abc,cba,nba,mba
alert(list.reverseString()) // mba,nba,cba,abc
alert(list) // abc,cba,nba,mba
任意位置插入

  • 向双向链表的任意位置插入数据会有一些复杂, 考虑的情况也会有一些多.

    // 在任意位置插入数据
DoublyLinkedList.prototype.insert = function (position, element) {
    // 1.判断越界的问题
    if (position < 0 || position > this.length) return false

    // 2.创建新的节点
    var newNode = new Node(element)

    // 3.判断插入的位置
    if (position === 0) { // 在第一个位置插入数据
        // 判断链表是否为空
        if (this.head == null) {
            this.head = newNode
            this.tail = newNode
        } else {
            this.head.prev = newNode
            newNode.next = this.head
            this.head = newNode
        }
    } else if (position === this.length) { // 插入到最后的情况
        // 思考: 这种情况是否需要判断链表为空的情况呢? 答案是不需要, 为什么?
        this.tail.next = newNode
        newNode.prev = this.tail
        this.tail = newNode
    } else { // 在中间位置插入数据
        // 定义属性
        var index = 0
        var current = this.head
        var previous = null
        
        // 查找正确的位置
        while (index++ < position) {
            previous = current
            current = current.next
        }
        
        // 交换节点的指向顺序
        newNode.next = current
        newNode.prev = previous
        current.prev = newNode
        previous.next = newNode
    }
    
    // 4.length+1
    this.length++
    
    return true
}

  • 代码深度解析, 代码比较复杂, 我们分成三种情况:

    • 情况一: 将元素插入到头部(position === 0)

      • 事实上, 将元素插入到头部是比较简单. 只是它有分成了两种情况.
      • 情况一: 列表为空. 那么直接让head/tail指向newNode即可
      • 情况二: 列表不为空, 这个时候需要修改原来head的prev指向新节点. 新节点的next指向原来的head. 并且head现在要指向newNode

      img

      img

    • 情况二: 将元素插入到尾部(position === length)

      • 这种情况比较简答了, 因为我们在append方法中已经处理过了.
      • 注意: 这里不需要判断元素为空的情况, 因为在position === 0的时候, 我们已经处理过了. 所以到这里的时候, 肯定不为空.

      img

      img

    • 情况三: 将元素插入到中间位置

      • 情况三是比较复杂一些的, 但是我们理清楚它的逻辑关系也就比较简单了.
      • 首先, 我们需要找到正确的插入位置. 通过while循环, 这个并不难, 因为我们在单向链表的时候已经找过了.
      • 查找正确的位置后, 需要进行插入操作.
      • 首先, 你的newNode的next/prev必然要指向前后的节点, 也就是current和previous
      • 其次, 而current的prev需要指向newNode, 而previous的next需要指向newNode.
      • 逻辑搞定, 并没有想象中的复杂, 详细看图解.

      img

      img

  • 测试一下该方法

    // 4.insert方法测试
list.insert(0, "100")
list.insert(2, "200")
list.insert(6, "300")
alert(list) // 100,abc,200,cba,nba,mba,300

  • 课下思考: 代码性能能否改进一点呢?

    • 如果我们position大于length/2, 是否从尾部开始迭代性能更高一些呢?
    • 对于初学者来说, 可以作为思考. 但是先搞定上面的内容吧.
位置移除数据

  • 我们继续来做下一个功能: 通过下标值删除某个元素

    // 根据位置删除对应的元素
DoublyLinkedList.prototype.removeAt = function (position) {
    // 1.判断越界的问题
    if (position < 0 || position >= this.length) return null

    // 2.判断移除的位置
    var current = this.head
    if (position === 0) {
        if (this.length == 1) {
            this.head = null
            this.tail = null
        } else {
            this.head = this.head.next
            this.head.prev = null
        }
    } else if (position === this.length -1) {
        current = this.tail
        this.tail = this.tail.prev
        this.tail.next = null
    } else {
        var index = 0
        var previous = null

        while (index++ < position) {
            previous = current
            current = current.next
        }

        previous.next = current.next
        current.next.prev = previous
    }

    // 3.length-1
    this.length--

    return current.element
}

  • 代码深度解析, 和插入一样, 可以分成三种情况:

    • 情况一: 删除头部的元素

      • 删除头部的元素也分成两种情况.
      • 情况一: 链表只有一个元素, 那么将head/tail直接设置为null即可
      • 情况二: 链表有多个元素, 这个时候删除头部的元素. head = head.next. head.prev = null

      img

      img

    • 情况二: 删除尾部的元素

      • 删除尾部的元素和删除头部有多个元素的情况比较相似. (也不需要考虑个数为1的情况, 因为上一种情况已经考虑了)
      • 将tail设置为tail的prev. tail的next设置为null即可.

      img

      img

    • 情况三: 删除中间位置的元素

      • 这种情况就需要先找到正确的位置, 还是使用while循环.
      • 将previous的next直接设置成current的next, 将current.next的prev设置成previous即可

      img

      img

  • 测试removeAt方法

    // 5.removeAt方法测试
alert(list.removeAt(0)) // 100
alert(list.removeAt(1)) // 200
alert(list.removeAt(4)) // 300
alert(list) // abc,cba,nba,mba
获取元素位置

  • 下面完成下一个功能: 根据元素获取再链表中的位置

    // 根据元素获取在链表中的位置
DoublyLinkedList.prototype.indexOf = function (element) {
    // 1.定义变量保存信息
    var current = this.head
    var index = 0

    // 2.查找正确的信息
    while (current) {
        if (current.element === element) {
            return index
        }
        index++
        current = current.next
    }

    // 3.来到这个位置, 说明没有找到, 则返回-1
    return -1
}

  • 代码解析:

    • 这个代码的实现和单向链表一样, 不再解释.

  • 代码测试:

    // 6.indexOf方法测试
alert(list.indexOf("abc")) // 0
alert(list.indexOf("cba")) // 1
alert(list.indexOf("nba")) // 2
alert(list.indexOf("mba")) // 3
根据元素删除

  • 有了上面的indexOf方法, 我们可以非常方便实现根据元素来删除信息

    // 根据元素删除
DoublyLinkedList.prototype.remove = function (element) {
    var index = this.indexOf(element)
    return this.removeAt(index)
}

  • 代码解析:

    • 和单向链表一样, 不再解释.

  • 测试代码:

    // 7.remove方法测试
alert(list.remove("abc")) // abc
alert(list) // cba,nba,mba
其他方法实现

  • 其他四个方法, 放在一起了

    // 判断是否为空
DoublyLinkedList.prototype.isEmpty = function () {
    return this.length === 0
}

// 获取链表长度
DoublyLinkedList.prototype.size = function () {
    return this.length
}

// 获取第一个元素
DoublyLinkedList.prototype.getHead = function () {
    return this.head.element
}

// 获取最后一个元素
DoublyLinkedList.prototype.getTail = function () {
    return this.tail.element
}

  • 代码解析:

    • 比较简单, 不再给出解释了.

  • 代码测试:

    // 8.测试最后四个方法
alert(list.getHead())
alert(list.getTail())
alert(list.isEmpty())
alert(list.size())

三. 完整代码

  • 给出双向链表的完整代码:

    // 创建双向链表的构造函数
function DoublyLinkedList() {
    // 创建节点构造函数
    function Node(element) {
        this.element = element
        this.next = null
        this.prev = null // 新添加的
    }

    // 定义属性
    this.length = 0
    this.head = null
    this.tail = null // 新添加的

    // 定义相关操作方法
    // 在尾部追加数据
    DoublyLinkedList.prototype.append = function (element) {
        // 1.根据元素创建节点
        var newNode = new Node(element)

        // 2.判断列表是否为空列表
        if (this.head == null) {
            this.head = newNode
            this.tail = newNode
        } else {
            this.tail.next = newNode
            newNode.prev = this.tail
            this.tail = newNode
        }

        // 3.length+1
        this.length++
    }

    // 在任意位置插入数据
    DoublyLinkedList.prototype.insert = function (position, element) {
        // 1.判断越界的问题
        if (position < 0 || position > this.length) return false

        // 2.创建新的节点
        var newNode = new Node(element)

        // 3.判断插入的位置
        if (position === 0) { // 在第一个位置插入数据
            // 判断链表是否为空
            if (this.head == null) {
                this.head = newNode
                this.tail = newNode
            } else {
                this.head.prev = newNode
                newNode.next = this.head
                this.head = newNode
            }
        } else if (position === this.length) { // 插入到最后的情况
            // 思考: 这种情况是否需要判断链表为空的情况呢? 答案是不需要, 为什么?
            this.tail.next = newNode
            newNode.prev = this.tail
            this.tail = newNode
        } else { // 在中间位置插入数据
            // 定义属性
            var index = 0
            var current = this.head
            var previous = null

            // 查找正确的位置
            while (index++ < position) {
                previous = current
                current = current.next
            }

            // 交换节点的指向顺序
            newNode.next = current
            newNode.prev = previous
            current.prev = newNode
            previous.next = newNode
        }

        // 4.length+1
        this.length++

        return true
    }

    // 根据位置删除对应的元素
    DoublyLinkedList.prototype.removeAt = function (position) {
        // 1.判断越界的问题
        if (position < 0 || position >= this.length) return null

        // 2.判断移除的位置
        var current = this.head
        if (position === 0) {
            if (this.length == 1) {
                this.head = null
                this.tail = null
            } else {
                this.head = this.head.next
                this.head.prev = null
            }
        } else if (position === this.length -1) {
            current = this.tail
            this.tail = this.tail.prev
            this.tail.next = null
        } else {
            var index = 0
            var previous = null

            while (index++ < position) {
                previous = current
                current = current.next
            }

            previous.next = current.next
            current.next.prev = previous
        }

        // 3.length-1
        this.length--

        return current.element
    }

    // 根据元素获取在链表中的位置
    DoublyLinkedList.prototype.indexOf = function (element) {
        // 1.定义变量保存信息
        var current = this.head
        var index = 0

        // 2.查找正确的信息
        while (current) {
            if (current.element === element) {
                return index
            }
            index++
            current = current.next
        }

        // 3.来到这个位置, 说明没有找到, 则返回-1
        return -1
    }

    // 根据元素删除
    DoublyLinkedList.prototype.remove = function (element) {
        var index = this.indexOf(element)
        return this.removeAt(index)
    }

    // 判断是否为空
    DoublyLinkedList.prototype.isEmpty = function () {
        return this.length === 0
    }

    // 获取链表长度
    DoublyLinkedList.prototype.size = function () {
        return this.length
    }

    // 获取第一个元素
    DoublyLinkedList.prototype.getHead = function () {
        return this.head.element
    }

    // 获取最后一个元素
    DoublyLinkedList.prototype.getTail = function () {
        return this.tail.element
    }

    // 遍历方法的实现
    // 正向遍历的方法
    DoublyLinkedList.prototype.forwardString = function () {
        var current = this.head
        var forwardStr = ""

        while (current) {
            forwardStr += "," + current.element
            current = current.next
        }

        return forwardStr.slice(1)
    }

    // 反向遍历的方法
    DoublyLinkedList.prototype.reverseString = function () {
        var current = this.tail
        var reverseStr = ""

        while (current) {
            reverseStr += "," + current.element
            current = current.prev
        }

        return reverseStr.slice(1)
    }

    // 实现toString方法
    DoublyLinkedList.prototype.toString = function () {
        return this.forwardString()
    }
}

作者：coderwhy
链接：https://www.jianshu.com/p/fb5a4169a618
来源：简书
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

H千面
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构与算法 c语言 线性表-静态链表
04-27
数据结构与算法 c语言 线性表-静态链表 静态链表源码
数据结构中一个题目引发的关于越界的问题
qq_62324715的博客
09-11 175
越界相关
单链表相关操作详解
Tai_Monster的博客
05-22 210
单链表相关操作的实现
双向链表、单双向链表比较、双向链表的基本操作
最新发布
weixin_71850179的博客
03-20 456
双向链表操作：创建、插入、遍历、查找、修改、删除、销毁
数据结构之数组和链表
王文平_Trista的博客
08-18 472
数组 1 是顺序存储的相同数据类型的数据结构，在内存空间上地址也是连续的，所以在声明数组的时候就要确定长度 声明数组 静态创建数组 int array[100];//定义一个大小100的数组，没有初始化 int array[2]= {1,2};//定义长度为2的数组，并初始化 int array[20]= {1,2};//定义长度为20的数组，并初始化前两个 new动态创建:使用new分配一个数...
【数据结构】数组：特性浅析
A minor
09-17 1271
1 数组是什么 数组（Array）是一种线性表数据结构。它用一组连续的内存空间，来存储一组具有相同类型的数据。 1.1 线性表结构 数组（Array）是一种线性表数据结构。它用一组连续的内存空间，来存储一组具有相同类型的数据。 线性表（Linear List）：顾名思义，线性表就是数据排成像一条线一样的结构。每个线性表上的数据最多只有前和后两个方向。其实除了数组，链表、队列、栈等也是线性表结构。 非线性表：是与线性表相对的概念，如二叉树、堆、图等。之所以叫非线性，是因为，在非线性表中，数据之间并不是简单的
数据结构之链表（C语言）
qq_74260823的博客
05-13 1780
链表是一种、非顺序的存储结构，数据元素的是通过链表中的次序实现的。链表有两个储存区，第一个储存区，第二个储存区储存1.2链表的分类链表可通过以下组合分类为八种。
嵌入式学习-02-数据结构和算法 (链表)
03-15
嵌入式学习-02-数据结构和算法 (链表)
数据结构与算法-顺序表（链表篇）
09-09
代码资源
数据结构-（单链表篇）
B_Small_panda的博客
01-16 980
数据结构-（单链表篇）
全网最详细线性表讲解（顺序表，链表）
陈某的博客
05-03 1069
有关数据结构中顺序表、链表的知识（C语言讲解）
链表边界检查
caiceyunchuang的专栏
06-04 153
为了保证链表处理正确，需要考虑其边界条件： 1、空链表的处理情况 2、只有一个结点的情况 3、只有两个结点的情况 4、头结点、wei
LeetCode初级算法题回顾（三）链表&树
Min220的博客
03-07 297
本回顾是对LeetCode 探索栏目中的“初级算法题”进行总结，归纳该栏目中做题的心得和体会。(注：不是leetcode中的所有简单难度的算法题) 该探索项目分为九个子栏目：数组、字符串、链表、树、排序和搜索、动态规划、设计问题、数学及其他。 关于链表的基础知识：LeetCode链表&链表概念梳理及代码示例 目录 A.链表 （主要考察指针） 链表初级算法题目一览 1）删除链表...
双向链表和单链表区别
m0_73247666的博客
07-11 3081
2、单向链表：单个结点创建非常方便，普通的线性内存通常在创建的时候就需要设定数据的大小，结点的访问方便，可以通过循环或者递归的方法访问到任意数据。2、单向链表：结点的删除非常方便，不需要像线性结构那样移动剩下的数据，但是平均的访问效率低于线性表。2、单向链表：是链表的一种，其特点是链表的链接方向是单向的，对链表的访问要通过顺序读取从头部开始。1、双向链表：也叫双链表，是链表的一种，每个数据结点中都有两个指针，分别指向直接后继和直接前驱。1、双向链表：增加删除节点复杂，需要多分配一个指针存储空间。
单向链表与双向链表区别
大伟伟的博客
10-25 7791
单向链表： 由两部分组成：数据域和指针域,每个结点都有一个指针，每个节点指针的指向都是指向自身结点的下一个结点，最后一个结点的head指向为null,对单链表的操作只能从一端开始，如果需要查找链表中的某一个结点，则需要从头开始进行遍历。 双向链表： 对于双向链表来说，它的每个节点要指向“直接前驱”和“直接后继”，所以节点类需要含有两个指针域。指向直接前驱的指针使用pre表示，指向后继的指针使用next表示。双向链表是在单向链表基础上的一个改进，每个节点指向其直接前驱和直接后继节点。因此，从双向链表的任
单链表和双链表的区别
天射手座的博客
01-23 9392
一、方向不同 单链表只有指向下一个结点的指针 双链表既有指向下一个结点的指针，也有指向上一个结点的指针 二、适用情况不同 单向链表更适合元素的增加与删除 双向链表更适合元素的查询工作 三、读取不同 单链表只能单向读取 双链表可以双向读取 ...
js 实现数据结构 -- 链表(LinkedList)
03-25 333
原文： 　　在 Javascript 中学习数据结构与算法。 概念： 　　链表存储有序的元素集合，但不同于数组，链表中的元素在内存中并不是连续放置的。每个 元素由一个存储元素本身的节点和一个指向下一个元素的引用(也称指针或链接)组成。下图展示了链表的结构: 　　相对于传统的数组，链表的一个好处在于，添加或移除元素的时候不需要移动其他元素。然而，链表需要使用指针，因此...
单向链表和双向链表有什么区别？各自有什么优缺点？
热门推荐
m0_37914467的博客
07-28 1万+
1、指向不bai同：单向链表只有du一个指向下一结点的指针，zhi双向链表除了有一个指dao向下一结点的指针外，还有一个指向前一结点的指针。 2、功能不同：单向链表只能next ，双向链表可以return。 3、单双向不同：单链表只能单向读取，双向链表可以通过prev()快速找到前一结点。 单向链表优缺点： 1、优点：单向链表增加删除节点简单。遍历时候不会死循环； 2、缺点：只能从头到尾遍历。只能找到后继，无法找到前驱，也就是只能前进。 双向链表优缺点： 1、优点：可以找到前驱和后继，可进可退
数据结构-双向循环链表
10-23
与单向链表不同的是，双向循环链表的尾节点的后继节点指向头节点，头节点的前驱节点指向尾节点，形成一个环形结构。这种结构的好处是可以方便地在链表中进行前后遍历，而不需要像单向链表那样记录前驱节点。在双向...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值