双向链表的实现

该双向链表在添加节点可根据节点中序号属性自动排序（升序）

package CSDN1;

/**
 * 双向链表
 * 实现增、删
 * @author Babulakaka
 * @create 2021-06-12 7:39
 */
public class DoubleLinkedListDemo {
    public static void main(String[] args) {
        DoubleLinkedList doubleLinkedList = new DoubleLinkedList();
        Node node1 = new Node(1);
        Node node5 = new Node(5);
        Node node4 = new Node(4);
        Node node8 = new Node(8);
        Node node2 = new Node(2);
        doubleLinkedList.addNode(node1);
        doubleLinkedList.addNode(node5);
        doubleLinkedList.addNode(node4);
        doubleLinkedList.addNode(node8);
        doubleLinkedList.addNode(node2);
        doubleLinkedList.show();
        System.out.println("删除测试");
       doubleLinkedList.deleteNode(2);
        doubleLinkedList.show();
    }
}

class Node {
    int val; //节点序号
    Node next; //下一个节点
    Node pre;//前一个节点

    public Node() {

    }

    public Node(int val) {
        this.val=val;
    }

    @Override
    public String toString() {
        return "Node{" +
                "val=" + this.val +
                '}';
    }
}

class DoubleLinkedList {
    public Node head=new Node();

    public void addNode(Node node) {
        Node temp = head;
//        while(true){//这个是尾插法
//            temp=temp.next;
//            if(temp.next==null){
//                break;
//            }
//        }
        //下面的是按序插入:升序
        boolean flag=false;
        while (true){
            if(head.next==null){
                break;
            }
            if(temp.next==null){
                break;
            }
            if(temp.next.val>node.val){
                flag=true;
                break;
            }
            temp=temp.next;
        }
        if(flag){
            temp.next.pre=node;
            node.next=temp.next;
            temp.next=node;
            node.pre=temp;
        }else{
            temp.next=node;
            node.pre=temp;
        }
        System.out.println("添加成功~~");
    }
    //链表的删除
    public void deleteNode(int val){
        Node temp=head;
        //判断链表是否为空
        if(isEmpty()){
            System.out.println("无法删除，链表为空");
            return;
        }
        boolean flag=false;
        while (true){//双向链表相较于单向链表，在删除时可以直接找到该节点进行删除,单链表需要找到其前一个节点。
            temp=temp.next;
            if(temp.val==val){
                flag=true;
                break;
            }
            if(temp.next==null){
                break;
            }
        }
        if(flag){
            temp.pre.next=temp.next;
            temp.next.pre=temp.pre;
        }else {
            temp.pre.next=null;
        }
        System.out.println("删除成功~~");
    }
    public void show(){
        Node temp=head;
        //判断是否为空
        if(isEmpty()){
            System.out.println("链表为空");
            return;
        }
        System.out.println("双向链表为：");
        while (true){
            temp=temp.next;
            System.out.println(temp.toString());
            if(temp.next==null){
                break;
            }
        }
    }

    //判断链表是否为空
    public boolean isEmpty() {
        return head == null;
    }
}