双指针算法

1.判断成环

给你一个链表的头节点 head ，判断链表中是否有环。

如果链表中有某个节点，可以通过连续跟踪 next 指针再次到达，则链表中存在环。 为了表示给定链表中的环，评测系统内部使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。注意：pos 不作为参数进行传递 。仅仅是为了标识链表的实际情况。

如果链表中存在环 ，则返回 true 。 否则，返回 false 。

解法：创建两个指针，一个快指针一个慢指针，一个走一步一个走两步，成环的链表肯定会相遇

public class Solution {
    public boolean hasCycle(ListNode head) {
        ListNode p1=head,p2=head;
        while(p2!=null&&p2.next!=null){
            p1=p1.next;
            p2=p2.next.next;
            if(p1==p2){
                return true;
            }
        }
        return false;
    }
}

2.判断成环位置

给定一个链表，返回链表开始入环的第一个节点。 从链表的头节点开始沿着 next 指针进入环的第一个节点为环的入口节点。如果链表无环，则返回 null。

为了表示给定链表中的环，我们使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。 如果 pos 是 -1，则在该链表中没有环。注意，pos 仅仅是用于标识环的情况，并不会作为参数传递到函数中。

说明：不允许修改给定的链表。

解法：

        我们使用两个指针，fast 与 slow。它们起始都位于链表的头部。随后，slow 指针每次向后移动一个位置，而 fast 指针向后移动两个位置。如果链表中存在环，则 fast 指针最终将再次与 slow 指针在环中相遇。

        如下图所示，设链表中环外部分的长度为 a。slow 指针进入环后，又走了 b 的距离与 fast 相遇。此时，fast 指针已经走完了环的 n 圈，因此它走过的总距离为 a+n(b+c)+b=a+(n+1)b+nc。

        根据题意，任意时刻，fast 指针走过的距离都为 slow 指针的 2 倍。因此，我们有

a+(n+1)b+nc=2(a+b)⟹a=c+(n−1)(b+c)
        有了 a=c+(n−1)(b+c) 的等量关系，我们会发现：从相遇点到入环点的距离加上 n−1 圈的环长，恰好等于从链表头部到入环点的距离。

        因此，当发现 slow 与 fast 相遇时，我们再额外使用一个指针 ptr。起始，它指向链表头部；随后，它和 slow 每次向后移动一个位置。最终，它们会在入环点相遇。

public class Solution {
    public ListNode detectCycle(ListNode head) {
        ListNode fast=head,slow=head;
        while(true){
            if(fast==null || fast.next==null){
                return null;
            }
            fast=fast.next.next;
            slow=slow.next;
            if(fast==slow){
                break;
            }
        }
        fast=head;
        while(fast!=slow){
            fast=fast.next;
            slow=slow.next;
        }
        return fast;
    }
      
}

3.删除链表的重复项

给定一个已排序的链表的头 head ， 删除所有重复的元素，使每个元素只出现一次 。返回 已排序的链表 。

题解：定义一个快指针，一个慢指针，快指针的值和慢指针的值不相等，让慢指针的next指向快指针，慢指针移向快指针位置，快指针指向下一个，让慢指针的下一个为null，如果相等则，快指针移动到下一个。

class Solution {
    public ListNode deleteDuplicates(ListNode head) {
        ListNode fast=head,slow=head;
        while(fast!=null){
            if(fast.val!=slow.val){
                slow.next=fast;
                slow=slow.next;
                
            }
            fast=fast.next;
            slow.next=null;
        }
        return head;
    }
}

4.合并两个有序链表

将两个升序链表合并为一个新的 升序 链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。 

解法：

两个指针指向两个链表的头指针，再定义一个新的节点a，让两个指针指向的节点比较大小，让节点a指向小的那个节点，指针指向下一个，a指针也指向下一个，等到有一个链表遍历完，让a指针指向没有遍历完的链表的指针。

class Solution {
    public ListNode mergeTwoLists(ListNode list1, ListNode list2) {
        ListNode newList=new ListNode(0);
        ListNode index=newList;
        while(list1!=null&&list2!=null){
            if(list1.val<list2.val){
                index.next=list1;
                list1=list1.next;
                index=index.next;
            }else{
                 index.next=list2;
                list2=list2.next;
                index=index.next;
            }
            
        }
        if(list1==null){
                index.next=list2;
            }else{
                index.next=list1;
            }
            return newList.next;
    }
}