双向链表

双向链表：

1.      什么是双向链表？

每个结点除了保存了对下一个结点的应用，同时还保存着对前一个结点的引用。

2.      从头部进行插入：

要对链表进行判断，如果为空则设置尾结点为新添加的节点。如果不为空，还需要设置头结点的前一个结点为新添加的结点。

3.      从尾部进行插入：

如果链表为空，则直接设置头结点为新添加的节点，否则设置尾结点的后一个结点为新添加的结点。同时设置新添加的结点的前一个结点为尾结点。

4.      从头部进行删除：

判断头结点是否有下一个结点，如果没有则设置结点为null否则设置头结点的下一个结点的previous为null。

 

双向链表的实现：

 

/*

 * 链结点，相当于是车厢

 */

public classNode {

    //数据域

    public long data;

    //指针域

    public Node next;

    public Node previous;

   

    public Node(long value) {

        this.data = value;

    }

   

    /**

     * 显示方法

     */

    public void display() {

        System.out.print(data + " ");

    }

}

 

/*

 * 双向链表

 */

public classDoubleLinkList {

    //头结点

    private Node first;

    //尾结点

    private Node last;

   

    public DoubleLinkList() {

        first = null;

        last = null;

    }

   

    /**

     * 插入一个结点，在头结点后进行插入

     */

    public void insertFirst(long value) {

        Nodenode = newNode(value);

        if(isEmpty()) {

            last = node;

        }else{

            first.previous = node;

        }

        node.next = first;

        first = node;

    }

   

    /**

     * 插入一个结点，从尾结点进行插入

     */

    public void insertLast(long value) {

        Nodenode = newNode(value);

        if(isEmpty()) {

            first = node;

        }else{

            last.next = node;

            node.previous = last;

        }

        last = node;

    }

   

    /**

     * 删除一个结点，在头结点后进行删除

     */

    public Node deleteFirst() {

        Nodetmp = first;

        if(first.next == null) {

            last = null;

        }else{

            first.next.previous = null;

        }

        first = tmp.next;

        return tmp;

    }

   

    /**

     * 删除结点，从尾部进行删除

     */

    public Node deleteLast() {

        Nodetmp = last;

        if(first.next == null) {

            first = null;

        }else{

            last.previous.next = null;

        }

        last = last.previous;

        return last;

    }

   

    /**

     * 显示方法

     */

    public void display() {

        Nodecurrent = first;

        while(current != null) {

            current.display();

            current= current.next;

        }

        System.out.println();

    }

   

    /**

     * 查找方法

     */

    public Node find(long value) {

        Nodecurrent = first;

        while(current.data != value) {

            if(current.next == null) {

                return null;

            }

            current= current.next;

        }

        return current;

    }

   

    /**

     * 删除方法，根据数据域来进行删除

     */

    public Node delete(long value) {

        Nodecurrent = first;

        while(current.data != value) {

            if(current.next == null) {

                return null;

            }

            current= current.next;

        }

       

        if(current == first) {

            first = first.next;

        }else{

            current.previous.next = current.next;

        }

        return current;

       

    }

   

    /**

     * 判断是否为空

     */

    public boolean isEmpty() {

        return (first == null);

    }

}

 

双向链表测试类：

public classTestDoubleLinkList {

    public static void main(String[] args) {

        DoubleLinkListdl = newDoubleLinkList();

        dl.insertLast(45);

        dl.insertLast(56);

        dl.insertLast(90);

        dl.display();

       

       

        while(!dl.isEmpty()) {

            dl.deleteFirst();

            dl.display();

        }

    }

}

运行结果：

45 56 90

56 90

90