单链表Java实现及单链表反转、快慢指针、单链表是否有环、单链表环入口

import java.util.Iterator;

public class MyOneWayLinkedList<T> implements Iterable{
     Node head;
    private int size;

    public MyOneWayLinkedList() {
        head = new Node(null,null);
        size = 0;
    }

    public int getSize() {
        return size;
    }

    // 在末尾添加增加元素
    public void put(T t){
        Node node = new Node(null,t);
        Node curr = head;
        while(curr.next!=null){
            curr = curr.next;
        }
        curr.next = node;
        size++;
    }
    // 在指定位置插入
    public void put(T t,int i){
        Node node = new Node(null,t);
        Node curr = head;
        for (int j = 0; j < i; j++) {
            if (curr.next!=null) curr = curr.next;
            else return;
        }
        node.next = curr.next;
        curr.next = node;
        size++;
    }
    // 删除
    public void delete(int i){
        Node n = head;
        for (int j = 0; j < i; j++) {
            if (n.next!=null) n=n.next;
            else return;
        }
        n.next = n.next.next;
        size--;
    }
    // 查询
    public T get(int i){
        if (this.size<i) return null;

        Node n = head;
        for (int j = 0; j <= i; j++) {
            n=n.next;
        }
        return n.value;
    }

    /**
     * 单链表反转
     */
    public void reverse(){
        if (this.head.next == null){
            return;
        }
        reverse(this.head);
    }

    /**
     * 反转节点
     * @param node 节点及其之后进行反转
     * @return 反转后的节点
     */
    public Node reverse(Node node){
        if (node.next == null) {
            this.head.next = node;
            return node;
        }
        reverse(node.next).next = node;
        return node;
    }

    /**
     * 查找单链表倒数第k个节点
     * @param k
     */
    public T getReverseOrderK (int k){
        if (k<1 || k>this.size) return null;
        Node first = head;
        Node last = head;
        for (int i = 0; i < this.size; i++) {
            first = first.next;
            // 倒数第1个索引是倒数第0
            if (i >= k-1) last = last.next;
        }
        return last.value;
    }

    /**
     * 判断单链表是否有环
     * @return
     */
    public boolean isCircle(){
        Node first = head;
        Node last = head;
        while (first.next.next != null){
            first = first.next.next;
            last = last.next;

            if (first == last) return true;
        }
        return false;
    }

    /**
     * @return 返回单链表环的入口节点
     */
    public Node getEntrance(){
        Node first = head;
        Node last = head;
        while (first.next.next != null){
            first = first.next.next;
            last = last.next;

            if (first == last) break;
        }
        Node temp = head;
        while (temp != last){
            last = last.next;
            temp = temp.next;
        }
        return temp;
    }



    /**
     * 节点类，包含 next 和 value
     */
    public class Node{
        Node next;
        T value;

        public Node(Node next, T value) {
            this.next = next;
            this.value = value;
        }
    }

    /*
     实现迭代器遍历
     */
    @Override
    public Iterator iterator() {
        return new TIterator();
    }

    private class TIterator implements Iterator{
        private Node n;
        public TIterator(){
            n = head;
        }
        @Override
        public boolean hasNext() {
            return n.next==null;
        }

        @Override
        public Object next() {
            n = n.next;
            return n.value;
        }
    }

}