小白也能学会的链表（青铜）

        此文章采用Java语言来完成本次挑战，挑战的内容是双向链表是：

1） 如何构造的，以及如何实现元素的插入和删除。  ‘

废话不多说，直接开始正文部分

一.先来谈谈个人对双向链表的理解

        首先，在我看来双向链表是基于单链表基本功能的升级，就好比之于某果手机的pro版本和数字版本。双向链表解决了单链表的单向查询麻烦，我们都知道链表由一个个节点和其对应指针构成，而节点则分为两个部分数据域和指针域。在单链表中，数据域用来存在元素的数值，指针域存放元素的指针，这个指针指向下一个节点。我将单链表比作贪吃蛇大作战时蛇头向蛇尾方向前进时，快要构成环而未成环的姿态，可以想来单链表的指针从来都是指向下一个元素,这样我们用起来就会觉得有些崩溃，单链表又如同生活只有继续而无暂停返回上个阶段很难，next不停的继续除非next=null了才会停止。与此同时，双向链表应运而生，我们先来看看他的模样：

 图一：双向链表示意图

可以清晰的看到这个双向链表有双向的箭头在每个节点上，这样就实现了“进可攻退可守”。prev指针（previous 上一个）指向之前的节点，而next指针指向下一个节点，data是改节点存放数据的数据域。

二.一起来看看怎么样用Java语言实现双向链表的构造

        （由于本人大一学习CPP语言而大二的数据结构课程教材又由C语言编写，而据我在大二的Java课程中了解到的Java语言没有指针这个玩意儿，C和CPP有指针的概念，我又对他知之甚少，在脑海里存放的就看到*p就是指针，指针里存放的是地址这么个浅显的理解（也不一定正确），接触Java语言后老师同学交流起来说Java语言里没有指针，所以也没有过多的了解，在一段时间的学习后才明白Java语言里的指针大概就是对象的引用这么一回事）

//创建双向链表的节点

class DoubleNode {
    public int data;    //数据域
    public DoubleNode next;    //指向下一个结点
    public DoubleNode prev;    //指向上一个结点
//构造器
    public DoubleNode(int data) {
        this.data = data;
    }

    //打印结点的数据域
    public void displayNode() {
        System.out.print("{" + data + "} ");
    }
}

在这段老师写的代码里，能看到双向链表有三个属性，却只有一个我们常见的属性 数据类型为int 的data变量。而其他两个属性也就是前文中所提到的指针域存放的指针了，来搂一眼就是哎 这个歌属性的数据类型怎么和我们的类名一样呢？这就是对象的引用了，Java里用和类名一样的数据类型而发起对象的引用。

图二：链表构建示意图

代码里用一个对象的引用指向下一个对象，以此构成所谓的”闭环贪吃蛇“，而在双向链表这个”蛇“就变成了双头蛇，一个头指向前节点，一个头指向后节点。就是代码里的DoubleNode  next和DoubleNode prev。

下面来看看怎么讲节点连成链

//初始化双向链表

public class DoublyLinkList {
    private DoubleNode first;//双向链表的头节点
    private DoubleNode last;//双向链表的尾节点
    public DoublyLinkList() {
        first = null;//将头节点置空
        last = first;//把头节点赋给尾节点
    }
    //从头部开始演绎
    public void displayForward() {
        System.out.print("List(first--->last): ");
        DoubleNode current = first;//把头节点赋给当前的双向链表节点
        while (current != null) {//此时开始循环赋值 原视频采用枚举法 枚举法会看的更加清晰一些但是为了保证代码的简洁美观还是采取了循环
            current.displayNode();
            current = current.next;//节点相连
        }
        System.out.println();
    }

    //从尾部开始演绎
    public void displayBackward() {
        System.out.print("List(last--->first): ");
        DoubleNode current = last;把头节点赋给当前的双向链表节点
        while (current != null) {
            current.displayNode();
            current = current.prev;
        }
        System.out.println();
    }

三.双向链表的插入与删除操作

插入

//头部插入
public void insertFirst(int data) {
    DoubleNode newDoubleNode = new DoubleNode(data);
    if (isEmpty()) {
        last = newDoubleNode;
    } else {//如果不是第一个结点的情况
        first.prev = newDoubleNode;    //将还没插入新结点之前链表的第一个结点的previous指向newNode
    }
    newDoubleNode.next = first;        //将新结点的next指向first
    first = newDoubleNode;          //将新结点赋给first（链接）成为第一个结点
}

//尾部插入
public void insertLast(int data) {
    DoubleNode newDoubleNode = new DoubleNode(data);
    if (isEmpty()) {
        first = newDoubleNode;        //若链表为空，则将first指向新的结点（newNode）
    } else {
        newDoubleNode.prev = last;//将last的previous指向last（last永远指向的是最后一个结点）【此时还没有插入新的结点newNode，所以last指向的是当前链表的最后一个结点】
        last.next = newDoubleNode;    //将last.next(当前链表最后一个结点的next域)指向新的结点newNode
    }
    last = newDoubleNode; //由于插入了一个新的结点，又因为是尾部插入，所以将last指向newNode
}

//某个结点的后部插入
public void insertAfter(int key, int data) {
    DoubleNode newDoubleNode = new DoubleNode(data);
    DoubleNode current = first;
    while ((current != null) && (current.data != key)) {//循环的终止条件是找完了或者没找到
        current = current.next;
    }
    //若当前结点current为空
    if (current == null) {//current为null有两种情况 一种是链表为空，一种是找不到key值
        if (isEmpty()) {//1、链表为空
            first = newDoubleNode;//则插入第一个结点（其实可以调用其它的Insert方法）
            last = newDoubleNode;//first和last均指向该结点（第一个结点）
        } else {
            last.next = newDoubleNode;//2、找不到key值
            newDoubleNode.prev = last;//则在链表尾部插入一个新的结点
            last = newDoubleNode;
        }
    } else {
        if (current == last) {//第三种情况，找到了key值，分两种情况
            newDoubleNode.next = null;//1、key值与最后结点的data相等
            last = newDoubleNode;//由于newNode将是最后一个结点，则将last指向newNode
        } else {
            newDoubleNode.next = current.next; //2、两结点中间插入                                                                                                                            四
            current.next.prev = newDoubleNode;  //将current当前结点的下一个结点赋给newNode.next
        } //将current下一个结点即current.next的previous域指向current
        current.next = newDoubleNode; //将当前结点的next域指向newNode
        newDoubleNode.prev = current; //将新结点的previous域指向current（current在newNode前面一个位置）
    }

}

//检查链表是否为空
public boolean isEmpty() {
    return (first == null);
} 

删除

//从头部删除结点
public DoubleNode deleteFirst() {
    DoubleNode temp = first;
    if (first.next == null) {            //若链表只有一个结点，删除后链表为空，将last指向null
        last = null;
    } else {
        first.next.prev = null;        //若链表有两个（包括两个）以上的结点 ，因为是头部插入，则first.next将变成第一个结点，其previous将变成null
    }
    first = first.next;                //将first.next赋给first
    return temp;                    //返回删除的结点
}

//从尾部删除结点
public DoubleNode deleteLast() {
    DoubleNode temp = last;
    if (first.next == null) {        //如果链表只有一个结点，则删除以后为空表,last指向null
        first = null;
    } else {
        last.prev.next = null;    //将上一个结点的next域指向null
    }
    last = last.prev;            //上一个结点称为最后一个结点，last指向它
    return temp;                    //返回删除的结点
}

//按值删除
public DoubleNode deleteKey(int key) {
    DoubleNode current = first;
    while (current != null && current.data != key) {        //遍历链表寻找该值所在的结点
        current = current.next;
    }
    if (current == null) {                        //若当前结点指向null则返回null，
        return null;                        //两种情况当前结点指向null，一是该链表为空链表，而是找不到该值
    } else {
        if (current == first) {                //如果current是第一个结点
            first = current.next;            //则将first指向它，将该结点的previous指向null,其余不变
            current.next.prev = null;
        } else if (current == last) {            //如果current是最后一个结点
            last = current.prev;        //将last指向当前结点的上一个结点（我们将当前结点除名了以后它便不再是最后一个了）
            current.prev.next = null;    //相应的要删除结点的上一个结点的next域应指向null
        } else {
            current.prev.next = current.next;        //当前结点的上一个结点的next域应指向当前的下一个结点
            current.next.prev = current.prev;    //当前结点的下一个结点的previous域应指向当前结点的上一个结点
        }
    }
    return current;        //返回
}