有环链表的环起点

题目：

给定一个有环链表，实现一个算法返回环路的开头节点
有环链表的定义：
在链表中某个节点的next元素指向在它前面出现过的节点，则表明该链表存在环路

解法一：
思路：
用hashset来判断重复元素，如果发现某个元素之前出现过，说明该链表存在环路，返回该节点。

代码：

package LianBiao;

import java.util.HashSet;

public class 有环链表的环起点 {
    //构建链表
    public static class ListNode{
        ListNode next;
        int value;

        public ListNode(int value) {
            this.value = value;
        }
    }

    //方法
    private static ListNode youHuan(ListNode head) {
        ListNode p=head;
        HashSet hashSet=new HashSet();
        while (true){ //一直循环到找到环起点
            if(hashSet.contains(p)){//说明之前出现过
                return p;
            }else {
                //未出现过
                hashSet.add(p);
                p=p.next;
            }
        }

    }
    //测试
    public static void main(String[] args) {
        ListNode head=new ListNode(3);
        head.next=new ListNode(9);
        head.next.next=new ListNode(6);
        head.next.next.next=new ListNode(34);
        head.next.next.next.next=new ListNode(43);
        head.next.next.next.next.next=new ListNode(34);
        head.next.next.next.next.next.next=head.next.next.next;
        ListNode node=youHuan(head);
        System.out.println(node.value);  //34
    }


}

解法二：
思路：
因为hashset要开辟新的空间，如果题目不要求开辟新的空间，这个时候我们可以利用链表的快慢指针。
慢指针：一次走一步
快指针：一次走两步
如果链表有环的话，他们两个最后一定会在某一点相遇。
快慢指针常用于判断一个链表是否有环
判断出来是否有环之后，那他们会在那点相遇呢？
因为f 比 s 快一倍，加入s 走了k 步后，刚进入环，那f 走了2k，在环的 k 处，假设环长为L ,则两者距离差L-k
换个角度想当进入环之后，就变成了f去追s ，s每走一步，两者距离便缩短1步，即两者再走L-k步，就相遇了。相遇在离 环起点k 步处。

怎么算k是多少呢？
让head和s一起走k步，他俩刚好在环起点相遇，即求得了环起点，也可以算出k

代码：

package LianBiao;

import java.util.HashSet;

/*给定一个有环链表，实现一个算法返回环路的开头节点
有环链表的定义：
在链表中某个节点的next元素指向在它前面出现过的节点，则表明该链表存在环路*/
public class 有环链表的环起点 {
    //构建链表
    public static class ListNode{
        ListNode next;
        int value;

        public ListNode(int value) {
            this.value = value;
        }
    }

    //方法一  hashset创建新空间求解
   /* private static ListNode youHuan(ListNode head) {
        ListNode p=head;
        HashSet hashSet=new HashSet();
        while (true){ //一直循环到找到环起点
            if(hashSet.contains(p)){//说明之前出现过
                return p;
            }else {
                //未出现过
                hashSet.add(p);
                p=p.next;
            }
        }

    }*/

   //方法二：不开辟新空间，快慢指针求解
    //可以先判断一下是否有环，当然本题中是明确说明有环的
   private static Boolean hasCircle(ListNode head) {
       ListNode s=head;
       ListNode f=head;
       while (true){
           s=s.next;   //慢指针
           f=f.next.next; //快指针
           if (f==null||f.next==null){  //说明是无环的，有环的不会出现节点next为null
               return false;
           }
           if (s==f){
               return true;
           }

       }

   }

   //方法二：不开辟新空间，快慢指针求解
    private static ListNode beginNode(ListNode head) {
        ListNode s=head;
        ListNode f=head;
        while (true){
            s=s.next;   //慢指针
            f=f.next.next; //快指针
            if (s==f){
                break; //两者相遇跳出循环，开始寻找环起点
            }
        }
        ListNode p=head;
        while (p!=s){ //两者不相遇，就一起走
            p=p.next;
            s=s.next;
        }
        return p; //当两者相遇，返回环起点

    }

    //测试
    public static void main(String[] args) {
        ListNode head=new ListNode(3);
        head.next=new ListNode(9);
        head.next.next=new ListNode(6);
        head.next.next.next=new ListNode(34);
        head.next.next.next.next=new ListNode(43);
        head.next.next.next.next.next=new ListNode(34);
        head.next.next.next.next.next.next=head.next;
       // ListNode node=youHuan(head);  //调用方法1
       // System.out.println(node.value);  //34
       /*Boolean b= hasCircle(head);
        System.out.println(b);*/  //判断有无环
        ListNode node=beginNode(head);
        System.out.println(node.value);


    }




}