数据结构（JavaScript）-----双向链表

1.双向链表

• 既可以从头遍历到尾，又可以从尾遍历到头
• 链表相连过程是双向的
• 一个节点既有向前连接的引用，也有一个向后连接的引用

2.双向链表缺点

• 每次在插入或删除某个节点时，需要处理四个引用，而不是两个
• 占用内存空间更大一些

3.双向链表的特点

• 可以使用一个head和一个tail分别指向头部和尾部的节点
• 每个节点都由三部分组成：前一个节点的指针(prev)，保存的元素(item)，后一个节点的指针(next)
• 双向链表的第一个节点的prev是null
• 双向链表的最后的节点的next是null

双向链表图：

4. 双向链表的封装

 //封装双向链表
        function DoublyLinkedList(){
   
            //属性
            this.head = null
            this.tail = null
            this.length = 0
            //内部类：节点类
            function Node(data){
   
                this.data = data
                this.prev = null
                this.next = null
            }
        }

5. 常见操作(增、删、改、查)

​

append(element):向列表尾部添加一个新的项

​ insert(position,element):向列表的特定位置插入一个新的项

​ get(position):获取对应位置元素

​ indexOf(element):返回元素在列表中的索引，如果列表中没有该元素则返回-1

​ update(position):修改某个位置的元素

​ remove(element):从列表中移除一项

​ removeAt(position):从列表的特定位置移除一项

​ isEmpty():判断链表是否为空，为空则返回true，否则返回false

​ size():返回链表包含的元素个数

​ toString():由于列表项使用了Node类，就需要重写继承自JavaScript对象默认的toString方法，让其只输出元素的值

​ forwardString():返回正向遍历的节点字符串形式

​ backwordString():返回反向遍历的节点字符串形式

• append()方法

 //append方法
            DoublyLinkedList.prototype.append = function(data){
   
                //根据data创建节点
                var newNode = new Node(data)

                //判断添加的是否是第一个节点
                if(this.length == 0){
   
                    this.head = newNode
                    this.tail = newNode
                }else{
   
                    newNode.prev = this.tail
                    this.tail.next = newNode
                    this.tail = newNode
                }
                this.length += 1
            }

• 链表转换成字符串

  //链表转成字符串形式
              DoublyLinkedList.prototype.toString = function(){
       
                  return this.backwardString()
              }
             
              //forwardString方法,向前遍历(从后往前)
              DoublyLinkedList.prototype.forwardString = function(){
       
                  //定义变量
                  var current = this.tail
                  var resultString = ""
  
                  //依次向前遍历，获取每一个节点
                  while(current){
       
                      resultString += current.data + " "
                      current = current.prev
                  }
                  return resultString
              }
            
              //backwardString方法，向后遍历(从前往后)
              DoublyLinkedList.prototype.backwardString = function(){
       
                  //定义变量
                  var current = this.head
                  var resultString = ""
                  //依次向后遍历，获取每一个节点
                  while(current){
       
                      resultString += current.data + " "
                      current = current.next
                  }
                  return resultString
              }
  

• insert()方法

 //insert方法
            DoublyLinkedList.prototype.insert = function(position,data){
   
                //越界判断
                if(position< 0 || position > this.length) return false
                //根据data创建新的节点
                var newNode = new Node(data)
                //判断原来的列表是否为空
                if(this.length == 0){
   
                    this.head = newNode
                    this.tail = newNode
                }else{
   
                    //判断position是否为0
                    if(position == 0){
   
                        this.head.prev = newNode
                        newNode.next =