判断链表是否存在环的两种思路及JAVA代码实现

import java.util.HashSet;
//判断是否是回文链表
public class HasCycle {
    public static void main(String[] args) {
        ListNode node1 = new ListNode(3);
        ListNode node2 = new ListNode(2);
        ListNode node3 = new ListNode(0);

        ListNode node4 = new ListNode(-4);

        node1.next = node2;
        node2.next = node3;
        node3.next = node4;
        //node4.next = node2;

        HasCycle test = new HasCycle();
        //测试思路1
        //boolean ans = test.hasCycle01(node1);
        //System.out.println(ans);

        //测试思路1
        boolean ans = test.hasCycle02(node1);
        System.out.println(ans);

    }

    //判断链表是否存在环
    //思路1：遍历单链表，把每一个节点的引用（地址）保存到一个集合中，然后查看当前结点的引用是否在集合中，
    // 如果在，则有环，如果当前结点的引用为null，说明以及遍历到结点的末尾，没有环
    public boolean hasCycle01(ListNode head) {
        if (head == null) {
            return false;
        }

        ListNode tmp = head;
        HashSet<ListNode> set = new HashSet<>();
        while (tmp != null) {
            if (set.contains(tmp)) {
                return true;
            } else {
                set.add(tmp);
            }
            tmp = tmp.next;
        }

        return false;
    }

    //思路2：快慢指针，快指针走两步，慢指针走一步，如果存在环，那么快指针一定会在某一时刻追上慢指针
    public boolean hasCycle02(ListNode head) {
        if (head == null || head.next == null) {
            return false;
        }
        //自己指向自己,自环
        if (head != null && head.next == head) {
            return true;
        }

        ListNode fast = head.next; //指向第二个结点。减少比较次数
        ListNode slow = head;

        while (fast != slow) {
            if (fast == null || fast.next == null) {
                return false;
            }
            slow = slow.next;
            fast = fast.next.next;
        }

        return true;
    }
}