【数据结构和算法7】环形链表的实现及基本功能操作（带哨兵，双向）-CSDN博客

本文链接：https://blog.csdn.net/zjj_flower/article/details/131490694

双向环形链表带哨兵，这时哨兵既作为头，也作为尾

实现代码

 package com.zjj.learn.algorithmPlus.segment1.linklist;
 
 import java.util.Iterator;
 
 /**
  * 双向环形链表的实现
  *
  * @author zjj_admin
  * @date 2023/7/16 12:54
  */
 public class RingLinkedListSentinel implements Iterable<Integer> {
 
 
     @Override
     public Iterator<Integer> iterator() {
         return new Iterator<>() {
             Node p = sentinel.next;
 
             @Override
             public boolean hasNext() {
                 return p != sentinel;
             }
 
             @Override
             public Integer next() {
                 int value = p.value;
                 p = p.next;
                 return value;
             }
         };
     }
 
     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 final Node sentinel = new Node(null, -1, null);
 
     public RingLinkedListSentinel() {
         sentinel.next = sentinel;
         sentinel.prev = sentinel;
     }
 
     /**
      * 添加到第一个
      *
      * @param value 待添加值
      */
     public void addFirst(int value) {
         Node next = sentinel.next;
         Node prev = sentinel;
         Node added = new Node(prev, value, next);
         prev.next = added;
         next.prev = added;
     }
 
     /**
      * 添加到最后一个
      *
      * @param value 待添加值
      */
     public void addLast(int value) {
         Node prev = sentinel.prev;
         Node next = sentinel;
         Node added = new Node(prev, value, next);
         prev.next = added;
         next.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;
     }
 
     /**
      * 删除最后一个
      */
     public void removeLast() {
         Node removed = sentinel.prev;
         if (removed == sentinel) {
             throw new IllegalArgumentException("非法");
         }
         Node a = removed.prev;
         Node b = sentinel;
         a.next = b;
         b.prev = a;
     }
 
     /**
      * 根据值删除节点
      * <p>假定 value 在链表中作为 key, 有唯一性</p>
      *
      * @param value 待删除值
      */
     public void removeByValue(int value) {
         Node removed = findNodeByValue(value);
         if (removed != null) {
             Node prev = removed.prev;
             Node next = removed.next;
             prev.next = next;
             next.prev = prev;
         }
     }
 
     private Node findNodeByValue(int value) {
         Node p = sentinel.next;
         while (p != sentinel) {
             if (p.value == value) {
                 return p;
             }
             p = p.next;
         }
         return null;
     }
 
 }