Java实现双向循环链表

上一篇文章实现了单向循环链表，双向很简单，在单向循环链表的基础上加一个前驱指针，

节点类如下：

/**
 * 双向链表节点
 */
public class Node
{
    private int data;//数据域
    private Node pre;//指向上一个节点
    private Node next;//指向下一个节点

    public int getData() {
        return data;
    }
    public void setData(int data) {
        this.data = data;
    }
    public Node getPre() {
        return pre;
    }
    public void setPre(Node pre) {
        this.pre = pre;
    }
    public Node getNext() {
        return next;
    }
    public void setNext(Node next) {
        this.next = next;
    }

    //构造函数
    public Node(int data, Node pre, Node next){
        this.data = data;
        this.pre = pre;
        this.next = next;
    }
    public Node(int data){
        this(data,null,null);
    }
    public Node(){
        this(0,null,null);
    }

}

具体实现：

/**
 * Java实现双向循环链表
 * Author：hangwei
 * 2022/11
 */
public class DLinkedList {
    private Node head;
    private Node tail;
    private int size;
    public Node getHead() {
        return head;
    }
    public Node getTail() {
        return tail;
    }
    public DLinkedList(){
        tail = head = null;
        size = 0;
    }

    /**
     * 在双向循环链表的任意位置之后新增一个节点
     * @param position 新增的位置，即新增节点的上一个节点
     * @param target 新增节点
     */
    public void addNode(Node position,Node target){
        if(target == null)
            return;
        if (size == 0) {
            target.setPre(target);
            target.setNext(target);
            tail = head = target;
        } else if (position == null) {//position为空就在链表尾部添加新节点
            tail.setNext(target);//尾节点的下一个节点是新节点
            target.setPre(tail);//新节点的上一个节点是尾节点
            target.setNext(head);//新节点的下一个节点是头节点
            //标记新的尾节点
            tail = target;
        } else {
            target.setPre(position);
            target.setNext(position.getNext());//原来position节点的下一个节点变成target的下一个节点
            position.setNext(target);
            if(size == 1 || position == tail)//标记新的尾节点
                tail = target;
        }
        size++;
    }

    /**
     * 删除链表中的任意节点
     * @param target 即将被删除的节点
     */
    public void deleteNode(Node target){
        if(size == 0 || target == null){
            System.out.println("null linked list ,can not delete.");
            return;
        }
        else if(size == 1){
            head = tail = null;
        }
        else {
            if(target == head){//如果目标是头节点
                head.getNext().setPre(tail);
                tail.setNext(head.getNext());
                head = head.getNext();
            }
            else {
                //计算目标节点的上一个节点
/*                Node n = new Node();//n表示target节点的上一个节点
                n = head;
                while (n.getNext() != tail) {//可以看到这里：当想要求解单向链表中的某个非头/尾节点时始终涉及到遍历
                    if (n.getNext() == target)
                        break;
                    n = n.getNext();
                }*/
                Node n = target.getPre();//双向循环链表这里不用计算上一个节点
                target.getNext().setPre(n);
                n.setNext(target.getNext());
                if(target == tail)//如果目标是尾节点
                    tail = n;//标记新的尾节点
            }
        }
        size--;
    }

    //打印链表
    public void print(){
        Node node = new Node();
        node = head;
        while (node.getNext() != head && node.getNext() != null){//遍历
            System.out.print(node.getData());
            System.out.print("<->");
            node = node.getNext();
        }
        System.out.print(node.getData());//补充打印循环体的最后一个节点
        System.out.print("<->");
        //最后打印出头节点
        System.out.print(head.getData());
        System.out.println();
    }
}

测试类：

public class Main {
    public static void main(String[] args) {
        //测试双向循环链表
        DLinkedList ll = new DLinkedList();
        ll.addNode(null,new Node(0));
        ll.print();
        ll.addNode(null,new Node(1));
        ll.addNode(null,new Node(2));
        ll.addNode(null,new Node(3));
        ll.print();
        ll.addNode(ll.getHead().getNext(),new Node(4));
        ll.print();
        ll.deleteNode(ll.getHead().getNext().getNext());
        ll.print();
        ll.deleteNode(ll.getHead());
        ll.print();
        ll.deleteNode(ll.getTail().getPre());
        ll.print();
    }
}

执行结果：

 

 

*重点：相比单向链表，双向链表的优点：不需要通过遍历(O(n))来查找某个节点的上一个节点。