双向链表的实现

管理单项链表的缺点分析：
1、单向链表，查找的方向只能是一个方向，而双向链表可以向前或者向后查找
2、单向链表不能自我删除，需要靠辅助节点，而双向链表，则可以自我删除，所以前面我们单链表删除节点时，总是找到temp，temp是待删除节点的前一个节点

分析双向链表的遍历，添加，修改，删除的操作思路：
1、遍历方法和单链表一样，只是可以向前，也可以向后
2、添加（默认添加到双向链表的最后）
（1）先找到双向链表的最后这个节点
（2）temp.next = newNode;
newNode.pre = temp;
3、修改的思路和原理和单向链表一样
4、删除：【要考虑特殊情况：删除的是最后一个【必须要判断删除的节点是否是最后一个节点，否则可能会报空指针异常】、删除的节点不存在】
（1）因为是双向链表，因此，我们可以实现自我删除某个节点
（2）直接找到要删除的节点，比如temp
（3）temp.pre.next = temp.next;
（4）temp.next.pre = temp.pre;

public class DoubleLinkedListDemo {

    public static void main(String[] args) {
        DoubleLinkedList1 list = new DoubleLinkedList1();

        Data data1 = new Data(1);
        Data data2 = new Data(2);
        Data data3 = new Data(3);
        Data data4 = new Data(4);
        Data data5 = new Data(5);
        Data data6 = new Data(6);

        list.addAtLast(data1);
        list.addAtLast(data2);
        list.addAtLast(data3);
        list.addAtLast(data4);
        list.addAtLast(data5);
        list.show();

        System.out.println("在第二个位置插入6========");
        list.addAtIndex(data6, 2);
        list.show();

        System.out.println("把4更新成999============");
        list.update(new Data(999), 4);
        list.show();

        System.out.println("删除999==========");
        list.delete(data4);
        list.show();

        System.out.println("删除888==========");
        try {
            list.delete(new Data(888));
        } catch (Exception e) {
            System.out.println(e.getMessage());
        }
        list.show();

        System.out.println("删除最后一个节点====");
        list.delete(data5);
        list.show();
    }

}

class DoubleLinkedList1 {
    private Data head;

    public DoubleLinkedList1() {
        head = new Data(-1);
    }

    /**
     * 默认添加在双向链表的末尾
     */
    public void addAtLast(Data newData) {
        Data cur = head;
        while (cur.next != null) {
            cur = cur.next;
        }
        cur.next = newData;
        newData.pre = cur;
    }

    public void addAtIndex(Data newData, int index) {
        if (index <= 0 || index > size()) {
            throw new RuntimeException("wrong index");
        }
        if (head.next == null) {
            System.out.println("链表为空");
        }
        Data cur = head;
        while (index-- > 0) {
            cur = cur.next;
        }
        newData.next = cur;
        newData.pre = cur.pre;
        cur.pre.next = newData;
        cur.pre = newData;
    }

    public void delete(Data deleteData) {
        if (head.next == null) {
            System.out.println("链表为空~");
        }
        Data cur = head.next;
        //判断是否找到了
        boolean flag = false;
        while (cur != null) {
            if (cur.num == deleteData.num) {
                cur.pre.next = cur.next;
                //必须要判断删除的节点是否是最后一个节点，否则可能会报空指针异常
                if (cur.next != null) {
                    cur.next.pre = cur.pre;
                }
                flag = true;
                break;
            }
            cur = cur.next;
        }
        if (!flag) {
            throw new RuntimeException("没有找到节点");
        }
    }

    /**
     * 把值为num的节点替换成新的节点
     *
     * @param updateData 新节点
     * @param num        原来节点的值
     */
    public void update(Data updateData, int num) {
        if (head.next == null) {
            System.out.println("链表为空");
        }
        Data cur = head.next;
        while (cur != null) {
            if (cur.num == num) {
                break;
            }
            cur = cur.next;
        }
        cur.num = updateData.num;
    }

    public int size() {
        if (head.next == null) {
            System.out.println("链表为空~");
            return 0;
        }
        Data cur = head.next;
        int count = 0;
        while (cur != null) {
            count++;
            cur = cur.next;
        }
        return count;
    }

    public void show() {
        if (head.next == null) {
            System.out.println("链表为空~");
        }
        Data cur = head;
        while (cur.next != null) {
            System.out.println(cur.next);
            cur = cur.next;
        }
    }

}

class Data {
    public int num;
    public Data next;
    public Data pre;

    public Data(int num) {
        this.num = num;
    }

    @Override
    public String toString() {
        return "Data{" +
                "num=" + num +
                '}';
    }
}

输出结果：
Data{num=1}
Data{num=2}
Data{num=3}
Data{num=4}
Data{num=5}
在第二个位置插入6========
Data{num=1}
Data{num=6}
Data{num=2}
Data{num=3}
Data{num=4}
Data{num=5}
把4更新成999============
Data{num=1}
Data{num=6}
Data{num=2}
Data{num=3}
Data{num=999}
Data{num=5}
删除999==========
Data{num=1}
Data{num=6}
Data{num=2}
Data{num=3}
Data{num=5}
删除888==========
没有找到节点
Data{num=1}
Data{num=6}
Data{num=2}
Data{num=3}
Data{num=5}
删除最后一个节点====
Data{num=1}
Data{num=6}
Data{num=2}
Data{num=3}

另：

/**
     * 按照添加的节点的值的大小顺序进入链表
     * @param newData   添加的节点
     */
    public void addInOrder(Data newData) {
        Data cur = head;
        while(cur!=null) {
            if(cur.num>newData.num) {
                newData.next = cur;
                newData.pre = cur.pre;
                cur.pre.next = newData;
                cur.pre = newData;
                break;
            }
            if(cur.next!=null){
                cur = cur.next;
            } else {
                //遍历到链表尾部都没有找到，说明应该插入到链表尾部
                cur.next = newData;
                newData.pre = cur;
                break;
            }
        }
    }