数据结构与算法-双向环形链表

双向环形链表（Doubly-Linked List）是一种常见的链表数据结构，它具有两个方向的指针，一个指向前一个节点，另一个指向后一个节点。双向环形链表可以用来实现栈、队列和优先队列等数据结构。

双向环形链表的实现通常涉及到三个数据结构：指针、节点和链表头结点。其中，指针用于存储节点的地址，节点用于存储节点的值，链表头结点用于存储链表的头指针。

在双向环形链表中，每个节点包含两个指针，一个指向前一个节点，另一个指向后一个节点。这样的设计使得双向环形链表可以在任意时刻只有一个指针指向头结点，从而实现了单向链表的功能。

双向环形链表的主要优点包括：
1、具有双向指针的能力，使得链表可以在任意时刻只有一个指针指向头结点，从而实现了单向链表的功能。
2、在双向环形链表中，任意一个节点可以同时指向两个方向，因此可以方便地实现栈、队列和优先队列等数据结构。
3、双向环形链表的空间利用率较高，因为每个节点只需要存储前一个节点和后一个节点的指针，而不需要存储节点的值。
4、双向环形链表的操作相对简单，因为只需要进行前向指针和后向指针的移动操作。
需要注意的是，双向环形链表在插入和删除节点时需要进行特殊的处理。例如，如果在插入一个节点之后，后一个节点指向的地址已经被占用，那么就需要将后一个节点的指针指向前一个节点，从而释放后一个节点的空间。如果在删除一个节点之后，前一个节点指向的地址已经被占用，那么就需要将前一个节点的指针指向后一个节点，从而释放前一个节点的空间。

总之，双向环形链表是一种非常实用的数据结构，可以用于实现栈、队列和优先队列等数据结构，并具有空间利用率高、操作简单等优点。

package com.demo._04双向链表;

import java.util.Iterator;

/**
 * @create 2023/5/6 9:35
 * @Desc 双向环形链表  1 -> 2 -> 3 -> 1
 **/
public class DoublyLinkedListSentinel02 implements Iterable<Integer>{

    @Override
    public Iterator<Integer> iterator() {
        return new Iterator<Integer>() {
            Node p = sentinel.next ;
            @Override
            public boolean hasNext() {
                return p != sentinel;
            }

            @Override
            public Integer next() {
                int value = p.value;
                p = p.next ;
                return value;
            }
        };
    }

    private static class Node{
        // 上一个节点
        Node prev ;
        // 值
        int value ;
        // 下一个节点
        Node next ;

        public Node(Node prev, int value, Node next) {
            this.prev = prev;
            this.value = value;
            this.next = next;
        }
    }
    // 哨兵对象
    private Node sentinel = new Node(null, -1, null) ;

    public DoublyLinkedListSentinel02() {
        sentinel.prev = sentinel;
        sentinel.next = sentinel;
    }

    /**
     * 添加头部元素
     * @param value 值
     */
    public void addFirst(int value) {

        Node a = sentinel ;
        Node b = sentinel.next;
        Node added = new Node(a, value, b);
        a.next = added ;
        b.prev = added ;
    }

    /**
     * 删除头部元素
     */
    public void removeFirst() {
        Node removed = sentinel.next;
        if(removed == sentinel) throw new IllegalArgumentException("非法") ;
        Node a = sentinel ;
        Node b = removed.next;
        a.next = b;
        b.prev = a;
    }

    /**
     * 添加尾元素
     * @param value 值
     */
    public void addLast(int value) {
        Node a = sentinel.prev ;
        Node b = sentinel ;
        Node added = new Node(a, value, b);
        a.next = added ;
        b.prev = added ;
    }

    /**
     * 删除尾元素
     */
    public void removeLast() {
        Node removed = sentinel.prev;
        if(removed == sentinel) throw new IllegalArgumentException("非法");
        Node a = removed.prev;
        Node b = this.sentinel;
        a.next = b;
        b.prev = a;
    }

    /**
     * 根据值删除
     * @param value 索引
     */
    public void removeByValue(int value) {
        Node removed = findByValue(value);
        if(removed == null) return;
        Node a = removed.prev;
        Node b = removed.next;
        a.next = b ;
        b.prev = a ;
    }

    private Node findByValue(int value) {
        Node p = sentinel.next;
        while (p != sentinel){
            if(p.value == value) {
                return p;
            }
            p = p.next ;
        }
        return null;
    }

    public static void main(String[] args) {

        // addFirst test
        DoublyLinkedListSentinel02 list = new DoublyLinkedListSentinel02() ;
        list.addFirst(1);
        list.addFirst(2);
        list.addFirst(3);
        list.addFirst(4);
        list.addFirst(5);

        // addLast test
        list.addLast(8);
        list.addLast(7);
        list.addLast(6);

        // removeFirst test
        list.removeFirst();

        // removeFirst test
        list.removeLast();

        // removeByValue test
        list.removeByValue(8);

        for (Integer integer : list) {
            System.out.println(integer);
        }

    }

}