双向链表-常见 *** 作（insert，get，indexOf，update）

// 5.insert方法

    DoublyLinkedList.prototype.insert=(position,data)=>{

//    1.越界判断

        if (position<0||position>this.length)return false

    //    2.根据data插入新的节点

        let newDate=new Node(data)

//    3.判断原来的列表是否为空

        if (this.length===0){

this.head=newDate

this.tail=newDate

}else if (position===0){//判断插入的position是否为

            //这里插入的是第一个位置，所以只需要改变head的值！

            this.head.prev=newDate

newDate.next=this.head

            this.head=newDate

}else if (position===this.length){//判断插入的位置position在最后面

            this.tail.next=newDate

newDate.prev=this.tail

            this.tail=newDate

}else {//insert到中间的节点上

            let index=0

            let current=this.head

            while (index++ <position){

current=current.next

            }

//    修改指针

            newDate.next=current

newDate.prev=current.prev

            current.prev.next=newDate

current.prev=newDate

}

//    length千万不要忘了

        this.length +=1

        return true

    }

//  6.get方法

    DoublyLinkedList.prototype.get=(position)=>{

//    1.越界判断（有关位置的一般都要进行越界判断！)

    //    2.获取元素if (position<0||position>=this.length) return  false

        let current=this.head

        let index=0

    //    3.遍历循环获取元素值

        while(index++

current=current.next

        }

return current.data

    }

//  7.indexOf方法

    DoublyLinkedList.prototype.indexOf=(data)=>{

//定义变量

        let current=this.head

        let index=0

        while (current){

if (current.data===data){

//这里返回的下标从0开始！

                return index

}

current=current.next

            index++

}

//-1表示的遍历了所有链表都没有找到

        return -1

    }

//  8.update方法

    DoublyLinkedList.prototype.update=(position,date)=>{

//    1.越界判断

        if (position<0||position>=this.length) {

return false

        }

//    2.遍历寻找正常的节点

        let current=this.head

        let index=0

        while (index++

current=current.next

        }

//  3.找到之后，更新所需要的节点

        current.data=date

// return true

      return true

    }

双向链表也叫双链表，是链表的一种，它的每个数据结点中都有两个指针，分别指向直接后继和直接前驱。所以，从双向链表中的任意一个结点开始，都可以很方便地访问它的前驱结点和后继结点。一般我们都构造双向循环链表

链表头 First

链表尾 Last

节点 Node

节点中数据域 data

节点中指针域 next

节点中指针域 prev

表头插入 insertFirst

表尾插入 insertLast

指定特定值的节点之后插入 insertAfter

表头删除 deleteFirst

表尾删除 deleteLast

添加第一个结点时

头结点和尾结点均指向新结点

first = newNode

last = newNode

添加新结点时

(1) 头结点指向新结点 first = newNode

(2) 新结点的next指向原有头结点 newNode.next = first

(3) 原有头结点的prev指向新结点 first.prev = newNode

(4) 尾结点指向原头结点，保持不变

添加第一个结点时

头结点和尾结点均指向新结点

first = newNode

last = newNode

新结点的prev指向null

添加新结点时

(1)头结点不变

(2)尾结点指向新结点 last = newNode

(3)原尾结点的next指向新结点 last.next = newNode

(4)新结点的prev指向原尾结点 newNode.prev = last

先找到当前结点

要插入结点为最后一个

(1) 尾结点指向新结点 last = newNode

(2) 当前结点next指向新结点 current.next = newNode

(3) 新结点的prev指向当前结点 newNode.prev = current

(4) 新结点的next指向null newNode.next = null

要插入结点为中间结点

(1) 头尾结点保持不变

(2) 当前结点的next指向指向新结点 current.next = newNode

(3) 新结点的prev指向当前结点 newNode.prev = current

(4) 新结点的next指向当前结点的下一结点 newNode.next = current.next

(5) 当前结点下一结点的prev指向新结点 current.next.prev = newNode

只有一个结点

(1) 头尾结点均为null first,last = null

有多个结点

(1) 头结点指向原头结点的下一结点 first = first.next

(2) 原头结点的下一结点prev为null first.next.prev = null

只有一个结点

(1) 头尾结点均为null first,last = null

有多个结点

(1) 尾结点指向原尾结点的上一结点 last = last.prev

(2) 原尾结点上一结点的next指向null last.prev.next = null

被删除的是第一个结点

(1)头结点指向当前结点下一结点 first = current.next

(2)当前结点下一结点的prev为null，current.next.prev = null 被删除的是最后一个结点

(1)尾结点指向当前结点上一结点，last = current.prev

(2)当前结点上一结点的next为null, current.prev.next = null 被删除的是中间结点

(1) 尾结点指向当前结点下一结点 last = current.next

(2) 当前结点上一结点的next指向当前结点的下一结点 current.prev.next = current.next

(3) 当前结点下一结点的prev指向当前结点的上一结点 current.next.prev = current.prev

---