双向链表与普通链表的区别在于，在链表中，一个节点只有链向下一个节点的链接，而双向链表中，链接是双向的：一个链向下一个元素，另一个链向前一个元素：

    双向链表的实现 - 图1

    1. class Node {
    2.   constructor(element) {
    3.     this.element = element
    4.     this.next = null // 保存前一个元素的引用
    5.     this.prev = null // 保存后一个元素的引用
    6.   }
    7. }
    9. class DoublyLinkedList {
    10.   constructor() {
    11.     this.length = 0 // 列表的元素个数
    12.     this.head = null // 保存列表的第一项
    13.     this.tail = null // 保存列表的最后一项
    14.   }
    16.   /**
    17.    * 往指定位置插入元素
    18.    * @param {number} position 
    19.    * @param {any} element 
    20.    */
    21.   insert(position, element) {
    22.     // 检查越界值，position 在 0 到 this.length 的范围为有效值
    23.     if (position < 0 || position > this.length) {
    24.       return false // 表示插入元素失败
    25.     }
    27.     let node = new Node(element)
    29.     if (position === 0) {
    30.       // 往列表第一个位置插入元素
    32.       if (this.length === 0) {
    33.         // 往空列表中插入元素，则列表的头部和尾部均指向同一个元素
    34.         this.head = node
    35.         this.tail = node
    36.       } else {
    37.         // 往非空列表中插入元素
    39.         let oldHead = this.head
    41.         node.next = oldHead
    42.         oldHead.prev = node
    43.         this.head = node
    44.       }
    45.     } else if (position === this.length) {
    46.       // 往列表末尾添加元素
    47.       let oldTail = this.tail
    49.       oldTail.next = node
    50.       node.prev = oldTail
    51.       this.tail = node
    52.     } else {
    53.       // 从列表中间插入元素
    54.       let previous = this.head
    55.       let current = this.head.next
    57.       for (let i = 1; i < this.length; i++) {
    58.         previous = current
    59.         current = current.next
    60.       }
    62.       previous.next = node
    63.       current.prev = node
    65.       node.prev = previous
    66.       node.next = current
    67.     }
    69.     this.length++
    71.     return true
    72.   }
    74.   /**
    75.    * 从指定位置删除元素
    76.    * @param {number} position 
    77.    */
    78.   removeAt(position) {
    79.     // 检查越界值
    80.     if (position < 0 || position >= this.length) {
    81.       return null
    82.     }
    84.     let result
    86.     if (position === 0) {
    87.       // 删除第一个位置的元素
    88.       result = this.head
    89.       if (this.length === 1) {
    90.         // 原来的列表中仅有一个元素
    91.         this.head = null
    92.         this.tail = null
    93.       } else {
    94.         let oldHead = this.head
    95.         // 将 this.head 改变 this.head 的下一个元素
    96.         this.head = oldHead.next
    97.         this.head.prev = null
    98.       }
    99.     } else if (position === this.length - 1) {
    100.       // 删除的是最后一个位置的元素
    101.       let oldTail = result = this.tail
    102.       this.tail = oldTail.prev
    103.       this.tail.next = null
    104.     } else {
    106.       let current = this.head
    107.       let previous = null
    109.       for(let i = 1; i <= position ; i++) {
    110.         previous = current
    111.         current = current.next
    112.       }
    114.       result = current
    116.       previous.next = current.next
    117.       current.next.prev = previous
    118.     }
    120.     this.length--
    122.     return result.element
    123.   }
    124. }