数据结构之单向循环链表

package datastruct.linearlist;

import java.lang.reflect.Array;
import java.util.Objects;

/**
 * 添加删除后维护尾头节点
 * 不能用while null作为判断条件
 */
public class HtqSinglyCircleLinkedList<E> {

    private static class Node<E>{
        E item;
        Node<E> next;

        public Node(E item, Node<E> next) {
            this.item = item;
            this.next = next;
        }
    }

    private int size;

    private Node<E> head;

    public HtqSinglyCircleLinkedList() {
    }

    //error size-1
    private Node<E> getLast(){
        Node<E> node = head;
       for (int i=0;i<size-1;i++){
            node = node.next;
        }
        return node;
    }

    private Node<E> beforeNode(Node<E> target){
        Node<E> node = head;
        while (node!=null){
            if (Objects.equals(node.next,target)){
                return node;
            }
            node = node.next;
        }
        return null;
    }

    private void linkFirst(E e){
        Node<E> newNode = new Node<>(e,head);
        head = newNode;
        size++;

        Node<E> last = getLast();
        last.next = head;
    }

    private void linkLast(E e){
        Node<E> l = getLast();
        Node<E> newNode = new Node<>(e,head);
        if (l==null){
            head = newNode;
        }else {
            l.next = newNode;
        }
        size++;
    }

    private void linkBefore(E e,Node<E> target){
       Node<E> pre = beforeNode(target);
       Node<E> newNode = new Node<>(e,target);
       if (pre==null){
           head = newNode;
       }else {
           pre.next = newNode;
       }
       size++;

       Node<E> last = getLast();
       last.next = head;
    }

    private E unLinkFirst(){
        Node<E> node = head;
        E e = node.item;

        head = head.next;

        node.item = null;
        node.next = null;
        node = null;

        size--;

        Node<E> last = getLast();
        last.next = head;
        return e;
    }

    private E unLinkLast(){
        Node<E> l = getLast();
        Node<E> pre = beforeNode(l);
        E e = l.item;
        l.next = null;
        l.item = null;
        l = null;
        if (pre==null){
            head = null;
        }else {
            pre.next = head;
        }

        size--;
        return e;
    }

    private E unLink(Node<E> target){
        E e = target.item;
        Node<E> pre = beforeNode(target);
        Node<E> next = target.next;
        target.item = null;
        target.next = null;
        target = null;
        if (pre==null){
            head = next;
        }else {
            pre.next = next;
        }
        size--;
        Node<E> last = getLast();
        last.next = head;
        return e;
    }

    public int size(){
        return size;
    }

    public boolean isEmpty(){
        return size==0;
    }

    public boolean contais(E e){
        return indexOf(e)!=-1;
    }

    public int indexOf(E e) {
        Node<E> node = head;
        for (int i=0;i<size;i++,node = node.next){
            if (Objects.equals(e,node.item)){
                return i;
            }
        }
        return -1;
    }

    public void clear(){
        Node<E> node = head;
        for (int i=0;i<size;i++){
            Node<E> temp = node;
            node = node.next;
            temp.item = null;
            temp.next = null;
            temp = null;
        }

        head = null;
        size = 0;
    }

    public Object[] toArray(){
        Object[] objects = new Object[size];

        Node<E> node = head;
        for (int i=0;i<size;i++,node = node.next){
            objects[i] = node.item;
        }
        return objects;
    }

    public <T> T[] toArray(T[] a){
        if (a.length<size){
            a = (T[])Array.newInstance(a.getClass().getComponentType(),size);
        }

        Object[] o = a;

        Node<E> node = head;
        for (int i=0;i<size;i++,node = node.next){
            o[i] = node.item;
        }

        if (a.length>size){
            a[size]=null;
        }

        return a;
    }

    public void add(E e){
        linkLast(e);
    }

    public void add(int index,E e){
        rangeCheckForAdd(index);

        linkBefore(e,node(index));
    }

    public E remove(int index){
        rangeCheck(index);

        return unLink(node(index));
    }

    public E remove(E e){
        Node<E> node = node(e);
        if (node==null) throw new IllegalArgumentException();
        return unLink(node);
    }

    public E set(int index,E e){
        rangeCheck(index);

        Node<E> node = head;
        for (int i=0;i<index;i++){
            node = node.next;
        }

        E oe = node.item;
        node.item = e;

        return oe;
    }

    public E get(int index){
        rangeCheck(index);
        return node(index).item;
    }

    private Node<E> node(E e){
        Node<E> node = head;
        for (int i=0;i<size;i++){
            if (Objects.equals(e,node.item)){
                return node;
            }
            node = node.next;
        }
        return null;
    }

    private Node<E> node(int index){
        Node<E> node = head;
        for (int i=0;i<index;i++){
            node = node.next;
        }
        return node;
    }

    public boolean isCircle(){
        Node<E> fast = head;
        Node<E> slow = head.next;
        while (fast.next!=null&&fast.next.next!=null){
            if (fast==slow){
                return true;
            }
        }
        return false;
    }

    private void rangeCheckForAdd(int index) {
        if (index<0||index>size)
            throw new IndexOutOfBoundsException();
    }

    private void rangeCheck(int index) {
        if (index<0||index>=size)
            throw new IndexOutOfBoundsException();
    }

    public void list(){
        Node<E> node = head;
        for (int i=0;i<size;i++,node = node.next){
            System.out.print(node.item+"_"+((node.next==null)?null:node.next.item)+"  ");
        }
        System.out.println();
    }
}