数据结构 -线性结构 ->双向链表

双向链表：就是在单向链表的基础上加了一个pre（指向该节点的前一个节点）域，其他的没有改变，在对链表进行增删相关操作时在单向链表的基础上多以一个向前节点连接的动作即可。

   　　　　因为有了指向前一个节点域，所以双向在查找数据上比单向的速度要快。

/**
 * 双向链表
 */
class DoubleLinkedList {
    private StartNode2 head = new StartNode2(0, " ", "");

    public StartNode2 getHead() {
        return head;
    }

    /**
     * 双向链表按照顺序添加数据
     */
    public void addByOder(StartNode2 startNode2) {
        StartNode2 temp = head;
        boolean flag = false;
        //循环链表，分别找到中间添加数据的标签和末端添加数据的标签
        while (true) {
            if (temp.next == null) {
                break;//添加结束
            }
            if (temp.next.no > startNode2.no) {
                break;
                //链表中按顺序添加数据
            }
            if (temp.next.no == startNode2.no) {
                flag = true;//添加数据有重复
                break;
            }
            temp = temp.next;
        }
        if (flag) {
            System.out.println("添加数据已有");
        } else {
            if (temp.next != null) {
                temp.next.pre = startNode2;//节点的前后指向有顺序要求，不同的顺序导致结果不一样，要先将插入节点与被比较节点的位置互换，再连接前节点
                startNode2.next = temp.next;
                temp.next = startNode2;
                startNode2.pre = temp;
            } else {
                temp.next = startNode2;//添加数据为链表最后
                startNode2.pre = temp;
            }
        }
    }

    /**
     * 双向链表添加数据，与单向链表差不多，需要在添加的数据上比单向多一个pre
     */
    public void add(StartNode2 startNode2) {
        StartNode2 temp = head;
        while (temp.next != null) {
            temp = temp.next;
        }
        temp.next = startNode2;
        startNode2.pre = temp;
    }

    /**
     * 显示链表，与单向链表相同
     */
    public void showList() {
        if (head.next == null) {
            System.out.println("链表为空~");
            return;
        }
        StartNode2 temp = head.next;
        while (temp != null) {
            System.out.println(temp);
            temp = temp.next;
        }
    }

    /**
     * 修改双向链表中的数据，与单向链表的修改数据方式相同
     */
    public void update(StartNode2 startNode2) {
        if (head.next == null) {
            System.out.println("链表为空！");
            return;
        }
        boolean flag = false;
        StartNode2 temp = head;
        while (temp.next != null) {
            if (temp.next.no == startNode2.no) {
                flag = true;
                break;//找到
            }
            temp = temp.next;
        }
        if (flag) {
            temp.next.name = startNode2.name;
            temp.next.nickName = startNode2.nickName;
        } else {
            System.out.println("没有修改");
        }
    }

    /**
     * 删除双向链表中的数据，与单向不同
     * 单向需要找到被删除节点的前一个节点
     * 双向链表则不同，只需要将需要删除的节点自身next，pre修改即可
     */
    public void delete(int num) {
        if (head.next == null) {
            System.out.println("链表为空！");
            return;
        }
        boolean flag = false;
        StartNode2 temp = head.next;
        while (true) {
            if (temp == null) {
                break;
            }
            if (temp.no == num) {
                flag = true;
                break;
            }
            temp = temp.next;
        }
        if (flag) {
            temp.pre.next = temp.next;//被删除数据的前一个数直接指向后一个，该数没有被指向，直接被jvm垃圾回收机制处理
            if (temp.next != null) {
                temp.next.pre = temp.pre;
            }
            System.out.printf("no为%d的数据已删除\n", num);
        } else {
            System.out.println("未找到数据，无删除");
        }

    }
}

class StartNode2 {
    int no;
    String name;
    String nickName;
    StartNode2 next;
    StartNode2 pre;

    public StartNode2(int no, String name, String nickName) {
        this.no = no;
        this.name = name;
        this.nickName = nickName;
    }

    @Override
    public String toString() {
        return "StartNode{" +
                "no=" + no +
                ", name='" + name + '\'' +
                ", nickName='" + nickName + '\'' +
                '}';
    }
}