【JavaScript数据结构系列】06-双向链表DoublyLinkedList

码路工人 CoderMonkey

转载请注明作者与出处

1. 认识双向链表

  • 不同于普通链表/单向链表，双向链表最突出的区别就是，

每一个元素节点上，除了保存数据，还有两个地址引用的指针，
一个指向前一个元素，一个指向后一个元素。

  • 我们比上一节还增加了一个 TAIL 的属性（末尾）
  • 能够以 HEAD -> TAIL 的方向遍历
  • 也能以 TAIL -> HEAD 的方向遍历

2. 常用方法

双向链表与单向链表非常相似，常用方法中除了方向遍历，其它都大致相同。

方法 描述
append(data) 向链表添加元素
insert(position, data) 向指定位置插入元素
remove(data) 删除元素
removeAt(position) 删除指定位置元素
update(position, data) 更新指定位置元素
getItem(position) 查找指定位置元素
indexOf(data) 获取元素位置
forwardTraverse(cb) 向Head方向遍历
backwardTraverse(cb) 向Tail方向遍历
traverse(cb, reversal) 指定方向遍历
getHead() 获取首元素数据
getTail() 获取尾元素数据
size() 获取链表大小
isEmpty() 判断链表是否为空
clear() 清空链表
toString() 字符串化

3. 代码实现

注：

ES6 版的代码实现请查看 npm 包 data-struct-js 代码

Github/Gitee 上都能找到

npm install data-struct-js

封装双向链表类

  1. /**
  2.  * 链表：双向链表
  3.  */
  4. function DoublyLinkedList() {
  5.   // 记录链表首元素
  6.   this.__head = null
  7.   // 记录链表尾元素
  8.   this.__tail = null
  9.   // 记录链表元素个数
  10.   this.__count = 0
  12.   // 用Node表示链表内部元素
  13.   function Node(data) {
  14.     this.data = data
  15.     this.prev = null	// 指向前元素
  16.     this.next = null	// 指向后元素
  18.     Node.prototype.toString = function () {
  19.       return this.data.toString()
  20.     }
  21.   }
  22. }

3.1 append(data)

向链表添加元素

  1. DoublyLinkedList.prototype.append = function (data) {
  2.   var newNode = new Node(data)
  4.   // 1.判断链表是否为空
  5.   if (this.__count === 0) {
  6.     // 新元素既是首也是尾
  7.     this.__head = newNode
  8.     this.__tail = newNode
  9.   }
  10.   // 2.非空链表时，添加到尾部
  11.   else {
  12.     this.__tail.next = newNode
  13.     newNode.prev = this.__tail
  14.     this.__tail = newNode
  15.   }
  17.   // 3.计数加1
  18.   this.__count += 1
  19. }

3.2 insert(position, data)

向链表中插入元素

  1. DoublyLinkedList.prototype.insert = function (position, data) {
  2.   // 1.边界检查（插入位置）
  3.   if (position < 0 || position > this.__count) return false
  5.   var newNode = new Node(data)
  7.   // 2.插入元素时链表为空
  8.   if (this.__count === 0) {
  9.     this.__head = newNode
  10.     this.__tail = newNode
  11.   }
  12.   // 3.链表非空
  13.   else {
  14.     // 3.1插入到链表头部
  15.     if (position === 0) {
  16.       newNode.next = this.__head
  17.       this.__head.prev = newNode
  18.       this.__head = newNode
  19.     }
  20.     // 3.2插入到链表尾部
  21.     else if (position === this.__count) {
  22.       this.__tail.next = newNode
  23.       newNode.prev = this.__tail
  24.       this.__tail = newNode
  25.     }
  26.     // 3.3以外
  27.     else {
  28.       var current = this.__head
  29.       var index = 0
  30.       while (index < position) {
  31.         current = current.next
  32.         index++
  33.       }
  34.       current.prev.next = newNode
  35.       newNode.prev = current.prev
  36.       newNode.next = current
  37.       current.prev = newNode
  38.     }
  39.   }
  41.   // 4.计数加1
  42.   this.__count += 1
  44.   return true
  45. }

3.3 removeAt(position)

删除指定位置元素

  1. DoublyLinkedList.prototype.removeAt = function (position) {
  2.   // 1.边界检查
  3.   if (position < 0 || position >= this.__count) return null
  5.   var current = this.__head
  7.   // 2.只有一个元素
  8.   if (this.size() === 1) {
  9.     this.__head = null
  10.     this.__tail = null
  11.   }
  12.   // 3.多个元素的情况
  13.   else {
  14.     // 3.1 删首
  15.     if (position === 0) {
  16.       current = this.__head
  18.       this.__head = current.next
  19.       current.next.prev = null
  20.     }
  21.     // 3.2 删尾
  22.     else if (position === this.__count - 1) {
  23.       current = this.__tail
  24.       this.__tail = current.prev
  25.       this.__tail.next = null
  26.     }
  27.     // 3.3 以外
  28.     else {
  29.       var index = 0
  30.       var current = this.__head
  31.       while (index < position) {
  32.         current = current.next
  33.         index += 1
  34.       }
  35.       current.prev.next = current.next
  36.       current.next.prev = current.prev
  37.     }
  38.   }
  40.   // 4.计数减1
  41.   this.__count -= 1
  43.   return current.data
  44. }

3.4 remove(data)

删除指定数据的元素

  1. DoublyLinkedList.prototype.remove = function (data) {
  2.   // 根据指定数据取得下标值
  3.   var index = this.indexOf(data)
  5.   // 检查下标值是否正常取到
  6.   if (index === -1) return null
  8.   // 根据取到的下标，调用 removeAt 方法进行删除
  9.   return this.removeAt(index)
  10. }

3.5 update(position, data)

更新指定位置元素的数据

  1. DoublyLinkedList.prototype.update = function (position, data) {
  2.   // 1.边界检查
  3.   if (position < 0 || position >= this.__count) return false
  5.   var current = this.__head
  6.   var index = 0
  8.   // 2.找到指定下标位置元素
  9.   while (index < position) {
  10.     current = current.next
  11.   }
  13.   // 3.修改数据
  14.   current.data = data
  16.   return true
  17. }

3.6 getItem(position)

获取指定位置的元素数据

  1. DoublyLinkedList.prototype.getItem = function (position) {
  2.   // 1.边界检查
  3.   if (position < 0 || position >= this.__count) return
  5.   var current = this.__head
  6.   var index = 0
  8.   // 2.找到指定下标位置元素
  9.   // => TODO：改善：根据position所在位置选择从Head还是从Tail开始查找
  10.   while (index++ < position) {
  11.     current = current.next
  12.   }
  13.   return current.data
  14. }

3.7 indexOf(data)

获取指定数据的元素位置（下标）

  1. DoublyLinkedList.prototype.indexOf = function (data) {
  2.   var current = this.__head
  3.   var index = 0
  5.   // 查找指定数据的节点
  6.   while (current) {
  7.     if (current.data == data) {
  8.       return index
  9.     }
  10.     current = current.next
  11.     index += 1
  12.   }
  13.   // 没有找到
  14.   return -1
  15. }

3.8 backwardTraverse(cb)

向Head方向遍历，通过回调函数传出每一个元素数据

  1. // Backward: Tail -> Head
  2. DoublyLinkedList.prototype.backwardTraverse = function (cb) {
  3.   // TODO: cb 参数检查（回调函数）
  5.   var current = this.__tail
  6.   while (current) {
  7.     cb(current.data)
  8.     current = current.prev
  9.   }
  10. }

3.9 forwardTraverse(cb)

向Tail方向遍历，通过回调函数传出每一个元素数据

  1. // Forward: Head -> Tail
  2. DoublyLinkedList.prototype.forwardTraverse = function (cb) {
  3.   // TODO: cb 参数检查（回调函数）
  5.   var current = this.__head
  6.   while (current) {
  7.     cb(current.data)
  8.     current = current.next
  9.   }
  10. }

3.10 traverse(cb, reversal)

指定遍历方向，调用上面的两个单独的方法进行遍历

  1. DoublyLinkedList.prototype.traverse = function (cb, reversal) {
  2.   if (!reversal) return this.forwardTraverse(cb)
  3.   return backwardTraverse(cb)
  4. }

3.11 getHead()

获取首元素数据

  1. DoublyLinkedList.prototype.getHead = function () {
  2.   if (this.__head == null) return null
  3.   return this.__head.data
  4. }

3.12 getTail()

获取尾元素数据

  1. DoublyLinkedList.prototype.getTail = function () {
  2.   if (this.__tail == null) return null
  3.   return this.__tail.data
  4. }

3.13 size()

查看元素个数方法

  1. DoublyLinkedList.prototype.size = function () {
  2.   return this.__count
  3. }

3.14 isEmpty()

判空方法

  1. DoublyLinkedList.prototype.isEmpty = function () {
  2.   return this.__count === 0
  3. }

3.15 clear()

实现分析：

Head、Tail指向全都置空

计数清零

  1. DoublyLinkedList.prototype.clear = function () {
  2.   this.__head = null
  3.   this.__tail = null
  4.   this.__count = 0
  5. }

3.16 toString()

为了方便查看实现的字符串化方法

  1. DoublyLinkedList.prototype.toString = function () {
  2.   var str = '[HEAD]'
  3.   var current = this.__head
  4.   while (current) {
  5.     str += ' -> ' + current.data
  6.     current = current.next
  7.   }
  8.   str += str == '[HEAD]' ?
  9.     ' -> Null <- [TAIL]' :
  10.   ' <- [TAIL]'
  11.   return str
  12. }

3.17 完整代码

  1. /**
  2.  * 链表：双向链表
  3.  */
  4. function DoublyLinkedList() {
  5.   // 记录链表首元素
  6.   this.__head = null
  7.   // 记录链表尾元素
  8.   this.__tail = null
  9.   // 记录链表元素个数
  10.   this.__count = 0
  12.   // 用Node表示链表内部元素
  13.   function Node(data) {
  14.     this.data = data
  15.     this.prev = null // 指向前元素
  16.     this.next = null // 指向后元素
  18.     Node.prototype.toString = function () {
  19.       return this.data.toString()
  20.     }
  21.   }
  23.   // 添加节点
  24.   DoublyLinkedList.prototype.append = function (data) {
  25.     var newNode = new Node(data)
  27.     // 1.判断链表是否为空
  28.     if (this.__count === 0) {
  29.       // 新元素既是首也是尾
  30.       this.__head = newNode
  31.       this.__tail = newNode
  32.     }
  33.     // 2.非空链表时，添加到尾部
  34.     else {
  35.       this.__tail.next = newNode
  36.       newNode.prev = this.__tail
  37.       this.__tail = newNode
  38.     }
  40.     // 3.计数加1
  41.     this.__count += 1
  42.   }
  44.   // 插入节点
  45.   DoublyLinkedList.prototype.insert = function (position, data) {
  46.     // 1.边界检查（插入位置）
  47.     if (position < 0 || position > this.__count) return false
  49.     var newNode = new Node(data)
  51.     // 2.插入元素时链表为空
  52.     if (this.__count === 0) {
  53.       this.__head = newNode
  54.       this.__tail = newNode
  55.     }
  56.     // 3.链表非空
  57.     else {
  58.       // 3.1插入到链表头部
  59.       if (position === 0) {
  60.         newNode.next = this.__head
  61.         this.__head.prev = newNode
  62.         this.__head = newNode
  63.       }
  64.       // 3.2插入到链表尾部
  65.       else if (position === this.__count) {
  66.         this.__tail.next = newNode
  67.         newNode.prev = this.__tail
  68.         this.__tail = newNode
  69.       }
  70.       // 3.3以外
  71.       else {
  72.         var current = this.__head
  73.         var index = 0
  74.         while (index < position) {
  75.           current = current.next
  76.           index++
  77.         }
  78.         current.prev.next = newNode
  79.         newNode.prev = current.prev
  80.         newNode.next = current
  81.         current.prev = newNode
  82.       }
  83.     }
  85.     // 4.计数加1
  86.     this.__count += 1
  88.     return true
  89.   }
  91.   // 删除指定位置节点
  92.   DoublyLinkedList.prototype.removeAt = function (position) {
  93.     // 1.边界检查
  94.     if (position < 0 || position >= this.__count) return null
  96.     var current = this.__head
  98.     // 2.只有一个元素
  99.     if (this.size() === 1) {
  100.       this.__head = null
  101.       this.__tail = null
  102.     }
  103.     // 3.多个元素的情况
  104.     else {
  105.       // 3.1 删首
  106.       if (position === 0) {
  107.         current = this.__head
  109.         this.__head = current.next
  110.         current.next.prev = null
  111.       }
  112.       // 3.2 删尾
  113.       else if (position === this.__count - 1) {
  114.         current = this.__tail
  115.         this.__tail = current.prev
  116.         this.__tail.next = null
  117.       }
  118.       // 3.3 以外
  119.       else {
  120.         var index = 0
  121.         var current = this.__head
  122.         while (index < position) {
  123.           current = current.next
  124.           index += 1
  125.         }
  126.         current.prev.next = current.next
  127.         current.next.prev = current.prev
  128.       }
  129.     }
  131.     // 4.计数减1
  132.     this.__count -= 1
  134.     return current.data
  135.   }
  137.   // 删除节点
  138.   DoublyLinkedList.prototype.remove = function (data) {
  139.     // 根据指定数据取得下标值
  140.     var index = this.indexOf(data)
  142.     // 检查下标值是否正常取到
  143.     if (index === -1) return null
  145.     // 根据取到的下标，调用 removeAt 方法进行删除
  146.     return this.removeAt(index)
  147.   }
  149.   // 更新节点数据
  150.   DoublyLinkedList.prototype.update = function (position, data) {
  151.     // 1.边界检查
  152.     if (position < 0 || position >= this.__count) return false
  154.     var current = this.__head
  155.     var index = 0
  157.     // 2.找到指定下标位置元素
  158.     while (index < position) {
  159.       current = current.next
  160.     }
  162.     // 3.修改数据
  163.     current.data = data
  165.     return true
  166.   }
  168.   // 获取节点数据
  169.   DoublyLinkedList.prototype.getItem = function (position) {
  170.     // 1.边界检查
  171.     if (position < 0 || position >= this.__count) return
  173.     var current = this.__head
  174.     var index = 0
  176.     // 2.找到指定下标位置元素
  177.     // => TODO：改善：根据position所在位置选择从Head还是从Tail开始查找
  178.     while (index++ < position) {
  179.       current = current.next
  180.     }
  181.     return current.data
  182.   }
  184.   // 获取下标
  185.   DoublyLinkedList.prototype.indexOf = function (data) {
  186.     var current = this.__head
  187.     var index = 0
  189.     // 查找指定数据的节点
  190.     while (current) {
  191.       if (current.data == data) {
  192.         return index
  193.       }
  194.       current = current.next
  195.       index += 1
  196.     }
  197.     // 没有找到
  198.     return -1
  199.   }
  201.   DoublyLinkedList.prototype.traverse = function (cb, reversal) {
  202.     if (!reversal) return this.forwardTraverse(cb)
  203.     return backwardTraverse(cb)
  204.   }
  206.   // Backward: Tail -> Head
  207.   DoublyLinkedList.prototype.backwardTraverse = function (cb) {
  208.     // TODO: cb 参数检查（回调函数）
  210.     var current = this.__tail
  211.     while (current) {
  212.       cb(current.data)
  213.       current = current.prev
  214.     }
  215.   }
  217.   // Forward: Head -> Tail
  218.   DoublyLinkedList.prototype.forwardTraverse = function (cb) {
  219.     // TODO: cb 参数检查（回调函数）
  221.     var current = this.__head
  222.     while (current) {
  223.       cb(current.data)
  224.       current = current.next
  225.     }
  226.   }
  228.   DoublyLinkedList.prototype.getHead = function () {
  229.     if (this.__head == null) return null
  230.     return this.__head.data
  231.   }
  233.   DoublyLinkedList.prototype.getTail = function () {
  234.     if (this.__tail == null) return null
  235.     return this.__tail.data
  236.   }
  238.   DoublyLinkedList.prototype.size = function () {
  239.     return this.__count
  240.   }
  242.   DoublyLinkedList.prototype.isEmpty = function () {
  243.     return this.__count === 0
  244.   }
  246.   DoublyLinkedList.prototype.clear = function () {
  247.     this.__head = null
  248.     this.__tail = null
  249.     this.__count = 0
  250.   }
  252.   DoublyLinkedList.prototype.toString = function () {
  253.     var str = '[HEAD]'
  254.     var current = this.__head
  255.     while (current) {
  256.       str += ' -> ' + current.data
  257.       current = current.next
  258.     }
  259.     str += str == '[HEAD]' ?
  260.       ' -> Null <- [TAIL]' :
  261.     ' <- [TAIL]'
  262.     return str
  263.   }
  264. }

4. 测试一下

  1. // ---------------------------------------------
  2. // Test: DoublyLinkedList
  3. // ---------------------------------------------
  4. console.log('----Test: DoublyLinkedList----')
  6. var dLst = new DoublyLinkedList()
  8. dLst.append('a')
  9. dLst.append('b')
  10. dLst.append('c')
  11. dLst.forwardTraverse(function (val) {
  12.     console.log('forward-traversing: ', val)
  13. })
  14. dLst.backwardTraverse(function (val) {
  15.     console.log('backward-traversing: ', val)
  16. })
  17. dLst.insert(0, 'Insert-Index=0')
  18. dLst.insert(3, 'Insert-Index=3')
  19. dLst.insert(5, 'Insert-Index=Count')
  20. console.log(dLst.toString())
  21. console.log('getItem(5) => ', dLst.getItem(5))
  22. console.log('remove("c") => ', dLst.remove('c'))
  23. console.log('removeAt(3) => ', dLst.removeAt(3))
  24. console.log('Result ↓ \r\n', dLst.toString())
  25. dLst.clear()
  26. console.log('After Clear : ', dLst.toString())

查看结果：

  1. ----Test: DoublyLinkedList----
  2. forward-traversing:  c
  3. forward-traversing:  b
  4. forward-traversing:  a
  5. backward-traversing:  a
  6. backward-traversing:  b
  7. backward-traversing:  c
  8. [HEAD] -> Insert-Index=0 -> a -> b -> Insert-Index=3 -> c -> Insert-Index=Count <- [TAIL]
  9. getItem(5) =>  Insert-Index=Count
  10. remove("c") =>  c
  11. removeAt(3) =>  Insert-Index=3
  12. [removeAt(3)]--Result ↓
  13.  [HEAD] -> Insert-Index=0 -> a -> b -> Insert-Index=Count <- [TAIL]
  14. After Clear :  [HEAD] -> Null <- [TAIL]

确认无误，收工。

做了一份 npm 工具包 data-struct-js ，
基于 ES6 实现的 JavaScript 数据结构，
虽然这个小轮子很少会被使用，
也许对于初学者学习 JavaScript 会有点帮助。
只要简单 install 一下即可，感兴趣的话还可以去
GitHub / Gitee 看源码。（Star 表支持～）

  1. npm install data-struct-js --save-dev

https://github.com/CoderMonkie/data-struct-js

https://gitee.com/coder-monkey/data-struct-js

最后，感谢您的阅读和支持~

-end-

【JavaScript数据结构系列】06-双向链表DoublyLinkedList的更多相关文章

  1. 【JavaScript数据结构系列】07-循环链表CircleLinkedList

    [JavaScript数据结构系列]07-循环链表CircleLinkedList 码路工人 CoderMonkey 转载请注明作者与出处 1. 认识循环链表 首节点与尾节点相连的,就构成循环链表.其 ...

  2. 【JavaScript数据结构系列】00-开篇

    [JavaScript数据结构系列]00-开篇 码路工人 CoderMonkey 转载请注明作者与出处 ## 0. 开篇[JavaScript数据结构与算法] 大的计划,写以下两部分: 1[JavaS ...

  3. JavaScript进阶系列06,事件委托

    在"JavaScript进阶系列05,事件的执行时机, 使用addEventListener为元素同时注册多个事件,事件参数"中已经有了一个跨浏览器的事件处理机制.现在需要使用这个 ...

  4. 【JavaScript数据结构系列】03-队列Queue

    [JavaScript数据结构系列]03-队列Queue 码路工人 CoderMonkey 转载请注明作者与出处 1. 认识队列Queue结构 队列,跟我们的日常生活非常贴近,我们前面举例了食堂排队打 ...

  5. 【JavaScript数据结构系列】05-链表LinkedList

    [JavaScript数据结构系列]05-链表LinkedList 码路工人 CoderMonkey 转载请注明作者与出处 ## 1. 认识链表结构(单向链表) 链表也是线性结构, 节点相连构成链表 ...

  6. 【JavaScript数据结构系列】04-优先队列PriorityQueue

    [JavaScript数据结构系列]04-优先队列PriorityQueue 码路工人 CoderMonkey 转载请注明作者与出处 ## 1. 认识优先级队列 经典的案例场景: 登机时经济舱的普通队 ...

  7. 【JavaScript数据结构系列】02-栈Stack

    [JavaScript数据结构系列]02-栈Stack 码路工人 CoderMonkey 转载请注明作者与出处 ## 1. 认识栈结构 栈是非常常用的一种数据结构,与数组同属线性数据结构,不同于数组的 ...

  8. 【JavaScript数据结构系列】01-数组Array

    [JavaScript数据结构系列]01-数组Array 码路工人 CoderMonkey 转载请注明作者与出处 # [JavaScript数据结构系列] # 01-数组Array 数组: 是有序的元 ...

  9. JavaScript进阶系列07,鼠标事件

    鼠标事件有Keydown, Keyup, Keypress,但Keypress与Keydown和Keyup不同,如果按ctrl, shift, caps lock......等修饰键,不会触发Keyp ...

随机推荐

  1. 动态规划经典算法--最长公共子序列 LCS

    转移方程 代码: //法一: #include <bits/stdc++.h> using namespace std; //---------------https://lunatic. ...

  2. P1516 青蛙的约会和P2421 [NOI2002]荒岛野人

    洛谷 P1516 青蛙的约会 . 算是手推了一次数论题,以前做的都是看题解,虽然这题很水而且还交了5次才过... 求解方程\(x+am\equiv y+an \pmod l\)中,\(a\)的最小整数 ...

  3. Jmeter 后置处理器

    1.JSON Extractor Json extractor 后置处理器用在返回格式为 Json 的 HTTP 请求中,用来获取返回的 Json 中的某个值.并保存成变量供后面的请求进行调用或断言等 ...

  4. Java中常用七个阻塞队列的总结

    Java队列总结 通过前面文章的学习,我们对Java中常用队列做了介绍.本文,咱们来对队列做个总结吧. 首先,我们介绍了现实生活中的实际场景(排队买票等),来告诉我们为什么需要使用队列. 队列是一种先 ...

  5. git新手使用教程包含各种系统

    Git Tutorial 1.下载客户端 从Git官网下载客户端:   https://git-scm.com/   Windows版下载地址:   https://git-scm.com/downl ...

  6. andorid jar/库源码解析之okhttp3

    目录:andorid jar/库源码解析 Okhttp3: 作用: 用于网络编程(http,https)的快速开发. 栗子: // okHttpClient定义成全局静态,或者单例,不然重复new可能 ...

  7. vue-infinite-scroll------vue的无线滚动插件

    vue-infinite-scroll------vue的无线滚动插件 博客说明 文章所涉及的资料来自互联网整理和个人总结,意在于个人学习和经验汇总,如有什么地方侵权,请联系本人删除,谢谢! 说明 V ...

  8. (技能篇)Mysql在linux下的全量热备份

    相关命令: #创建备份目录 mkdir -p /mysqlbackup #进入创建的备份目录中 cd /mysqlbackup #如果mysql运行在mysql用户和用户组下面,root表示用户,my ...

  9. java web 开发之 office（excel、doc等）文件转pdf

    一.开发工具:office 16.jacob-1.18-M2.jboss 1.6 二.开发配置: 1.解压缩---> 2.配置jacob: A C:\Windows\System32 jacob ...

  10. 自己动手在Linux系统实现一个everything程序

    大家好,我是良许. 我们知道,在 Windows 下,有一款非常实用的神器,叫作 Everything ,它可以在极短的时间里,搜索出来你所想要的文件/目录,如下图示: Linux 下也有一些类似于 ...