JAVA实现双向链表超详解（图解）
这一篇，说一下双链表的实现，双向链表一定是在单链表的基础上，进行优化，才能成为双链表，关于单链表的文章，可以看下面这个链接：
https://blog.csdn.net/weixin_46726346/article/details/107687955
所以一些重复的东西就不会再说了，言归正传，我们开始说双向链表；
之前说过单链表的结构，我们再来看一下：
单链表的查询方式，只能通过顺序遍历一遍才能查询，这也是单链表的一个缺陷，那有没有什么解决办法，或者是优化办法，这个时候双向链表出现了！
我们来看一下双向链表的结构：
可以看到，头节点除了first，还有一个last指向最后一个节点的pre，每个节点除了next还有一个pre来指向上一个节点的地址。
那这么做有什么用呢，看图，如果我想找到3号元素，按以前的单链表，是不是只能先找0，再找1，再找2，最后找3.
现在呢，有了这个pre，我是不是直接last就是3，从后面找是不是就更快了。
那，知道了双向链表的结构，现在我们就可以开始写代码了！
一、节点类
节点类，只是在之前的情况下，加了一个pre对吧，我们再改一下构造函数，就可以了。
public class Node<E> {
E element;
Node pre;
Node next;
public Node(Node pre,Node next,E element) {
this.next=next;
this.pre=pre;
this.element=element;
}
}
然后链表类要加上一个last成员变量：
public class DoubleList<E> {
private Node first;
private Node last;
private int size;
}
二、获取节点的方法
获取节点的方法，就不能用以前单链表的了，我们要判断要获取节点的位置，如果在中间靠前，我们就依旧用next查询，如果靠后，那就要用pre来进行查询：
那怎么判断是在前面还是在后面呢，很简单的，我们有size啊，判断index和size>>1（size的一半）的大小就可以了。
private Node<E> node(int index){
Node x=first;
if(index>size>>1) {
x=last;
for(int i=size-1;i>index;i--) {
x=x.pre;
}
}
else {
for(int i=0;i<index;i++) {
x=x.next;
}
}
return x;
}
因为这个方法不被外界调用，所以我们可以设置成私有的；
三、添加元素
我们先来考虑特殊的情况。
如果我们第一次添加元素的话，头节点的first和last应该都为空；
并且，记住啊，此时size=index=0.
我现在新插入一个节点，是不是应该让firs和last都t指向新节点，并且新节点的next和pre都是空，因为只有自己一个节点啊。
好记住这个逻辑，我们再看第二种情况，在尾部添加节点。
直接看上面这个图就行，我要在这个new节点后面再加一个，是不是new这个节点的next从null变成指向新节点，pre不变，first不变，但last是不是要指向新的节点，新节点的next要设置为空，新节点的pre要指向这个new。对吧，注意的是，此时的size=index=1，没毛病吧！
OK ，现在我们思考一个问题，除了这两种情况（无节点情况，在末尾添加节点），还有没有size=index的情况了，没有，很确定，没有了。那我是不是就可以把这两种情况综合为size==index的判断条件中呢？
if(index==size) {
Node l=last;
Node newNode=new Node(l,null,element);
last=newNode;
if(l==null) {
first=newNode;
}
else {
l.next=newNode;
}
}
我现在再把实现这个过程的代码拿出来，对照着这个图，是不是就可以理解了！l=null代表的就是没有节点的情况，仔细看看代码。
现在我们再来考虑index！=size的情况，看最开始的那张图：
我如果想在1号位置添加节点，是不是就相当于是，在原来的0号节点和1号节点中间添加一个new节点，然后0的next指向new，1的pre指向new，new的next指向1，new的pre指向0；
有点绕，逻辑就是这样：
看一下图吧，我画的有点乱
逻辑出来了，那就用代码来实现一下：
else {
Node node=node(index);
Node pre=node.pre;
Node newNode=new Node(pre,node,element);
node.pre=newNode;
if(pre==null) {
first=newNode;
}
else {
pre.next=newNode;
}
}
那，在代码里面，有一个值得注意的问题，就是我们判断了一下pre这个节点是不是空，代表了什么呢，如果pre是空，是不是就是说你要在0号节点添加元素，也就是在0号元素前面插上一个节点，那么我就让first指向new出来的节点不就行了嘛。
然后我们就来总的看一下这个方法：
public void add(int index,E element) {
if(index==size) {
Node l=last;
Node newNode=new Node(l,null,element);
last=newNode;
if(l==null) {
first=newNode;
}
else {
l.next=newNode;
}
}
else {
Node node=node(index);
Node pre=node.pre;
Node newNode=new Node(pre,node,element);
node.pre=newNode;
if(pre==null) {
first=newNode;
}
else {
pre.next=newNode;
}
}
size++;
}
然后add还有一个在末尾添加的方法，这里也不多说了，在上一篇文章有说过，直接看代码。
public void add(E element) {
add(size,element);
}
四、获取和修改方法
这和单链表的是一样的，也不说了：
public E get(int index) {
if(index<0||index>size) {
throw new IndexOutOfBoundsException("索引越界异常");
}
return node(index).element;
}
public E set(int index,E element) {
if(index<0||index>size) {
throw new IndexOutOfBoundsException("索引越界异常");
}
Node<E> node=node(index);
E oldElement=node.element;
node.element=element;
return oldElement;
}
五、toString方法
依旧是和单链表一样，这里也不说啦：
public String toString() {
StringBuilder str=new StringBuilder();
if(size==0) {
return "[]";
}
else {
str.append("[");
Node x=first;
for(Node i=x;i!=null;i=i.next) {
if(i.next==null) {
str.append(i.element).append("]");
}
else {
str.append(i.element).append(" ");
}
}
return str.toString();
}
}
奥，最后一个，删除节点，又是恶心的来了，来，奥利给！
六、删除节点
依旧是很恶心，我们还是分情况来看，首先呢，不管什么情况，你要删除某个节点的话，一定要获取到这个节点的前一个节点和后一个节点对吧；
Node <E>node=node(index);
Node pre=node.pre;
Node next=node.next;
然后我们说第一种另类情况，假如我们删除最后一个节点，也就是next=null的情况对吧；
也就是删除3号节点，应该让2号节点的next为null，然后让last指向2号节点对吧；
逻辑跟简单吧，好，现在我们记住这个逻辑，然后我们来看另一种情况，删除0号元素这种特殊情况。
如果我们想删除0号元素。
是不是应该让first指向1号元素，然后让1号元素的pre指向空。
OK，这个逻辑也要记住，那现在要思考一个问题，我在删除0号元素有没有特殊的情况，否定了这种逻辑呢。那就往特殊的逻辑里面想啊。
如果我链表中只有一个节点，是不是逻辑就变了！
我现在要把这个节点删除掉的话，是不是要让first和last都指向空就完了，不需要指向其他的节点了，否则会发生空指针异常的！
所以光特殊的情况就有三种呢，现在来看一下最普通的情况：
我们要删除1号节点的话，是不是让0的next指向2,2的pre指向0,1号节点不就滚犊子了吗，对吧；
OKK，现在所有的逻辑已经说完了，我们就来看一下代码是怎么实现这个逻辑的！
public E remove(int index) {
if(index<0||index>size) {
throw new IndexOutOfBoundsException("索引越界异常");
}
Node <E>node=node(index);
Node pre=node.pre;
Node next=node.next;
if(pre==null) {
first=next;
if(next==null) {
last=null;
}
else {
next.pre=null;
}
}
else {
pre.next=next;
}
if(next==null) {
last=pre;
}
else {
next.pre=pre;
}
size--;
return node.element;
}
还是解释一下吧，直接自己看可能还是有点费劲，前三行是获取当前节点，还有前一个和后一个。然后判断pre是不是null，不就是判断删除的节点是不是0号节点吗。然后在这个判断中，又判断了next是不是null，不就是判断了链表中是否就有一个节点吗。然后下一个if语句中判断next是否为null，判断的不就是该节点是否为最后一个节点的情况吗。
然后就完事了，整个删除方法也就全写完了！
七、测试方法
public class Test {
public static void main(String[] args) {
DoubleList<Integer> list=new DoubleList();
list.add(1);
list.add(2);
list.add(3);
System.out.println(list);
list.add(0,2);
System.out.println(list);
list.set(0, 7);
System.out.println(list);
System.out.println(list.get(3));
list.remove(2);
System.out.println(list);
}
}
然后我们再看一下输出结果吧！
[1 2 3]
[2 1 2 3]
[7 1 2 3]
3
[7 1 3]
也是没有问题的啊。
OK ，这就是双向链表，完全是基于单向链表的一个优化，所以想学习双向链表，一定要知道单向链表的实现是如何做到的，再次分享一下链接：
https://blog.csdn.net/weixin_46726346/article/details/107687955
OK，分享结束。