快慢指针的应用

1.判断单链表是否存在环

* Definition for singly-linked list.
 * public class ListNode {
 *     public int val;
 *     public ListNode next;
 *     public ListNode(int x) {
 *         val = x;
 *         next = null;
 *     }
 * }
 */
public class Solution {
    public bool HasCycle(ListNode head) {
         if(head == null){
            return false;
        }
        ListNode slow = head;
        ListNode fast = head;
        while (fast !=null && fast.next!=null){
            slow = slow.next;
            fast = fast.next.next;
            if(slow == fast){
                return true;
            }
        }
        return false;
    }
}

 如果链表存在环，就好像操场的跑道是一个环形一样。此时让快慢指针都从链表头开始遍历，快指针每次向前移动两个位置，慢指针每次向前移动一个位置；如果快指针到达NULL，说明链表以NULL为结尾，没有环。如果快指针追上慢指针，则表示有环.

2.判断两个单链表是否相交，如果相交，找到他们的第一个公共节点

编写一个程序，找到两个单链表相交的起始节点。

如下面的两个链表：

在节点 c1 开始相交。

示例 1：

输入：intersectVal = 8, listA = [4,1,8,4,5], listB = [5,0,1,8,4,5], skipA = 2, skipB = 3
输出：Reference of the node with value = 8
输入解释：相交节点的值为 8 （注意，如果两个列表相交则不能为 0）。从各自的表头开始算起，链表 A 为 [4,1,8,4,5]，链表 B 为 [5,0,1,8,4,5]。在 A 中，相交节点前有 2 个节点；在 B 中，相交节点前有 3 个节点。

示例 2：

输入：intersectVal = 2, listA = [0,9,1,2,4], listB = [3,2,4], skipA = 3, skipB = 1
输出：Reference of the node with value = 2
输入解释：相交节点的值为 2 （注意，如果两个列表相交则不能为 0）。从各自的表头开始算起，链表 A 为 [0,9,1,2,4]，链表 B 为 [3,2,4]。在 A 中，相交节点前有 3 个节点；在 B 中，相交节点前有 1 个节点。

示例 3：

输入：intersectVal = 0, listA = [2,6,4], listB = [1,5], skipA = 3, skipB = 2
输出：null
输入解释：从各自的表头开始算起，链表 A 为 [2,6,4]，链表 B 为 [1,5]。由于这两个链表不相交，所以 intersectVal 必须为 0，而 skipA 和 skipB 可以是任意值。
解释：这两个链表不相交，因此返回 null。

这道题有三种解决方法
（1)利用快慢指针将链表1的尾结点的next赋给链表2的头结点，在循环过程中如果slow==fast则证明存在环，之后再创建一组快慢指针找到相的结点

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     public int val;
 *     public ListNode next;
 *     public ListNode(int x) { val = x; }
 * }
 */
public class Solution {
    public ListNode GetIntersectionNode(ListNode headA, ListNode headB) {
        if(headA==null||headB==null)
            return null;
        ListNode tmp=headB;
        while(tmp.next!=null)
        {
            tmp=tmp.next;
        }
        tmp.next=headB;
        ListNode slow=headA;
        ListNode fast=headA;
        while(fast!=null&&fast.next!=null)
        {
            slow=slow.next;
            fast=fast.next.next;
            if(fast==slow)
            {
                slow=headA;
                while(slow!=fast)
                {
                    slow=slow.next;
                    fast=fast.next;
                }
                tmp.next=null;
                return fast;
            }
        }
        tmp.next=null;
        return null;
    }
}

（2)两链表相连

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     public int val;
 *     public ListNode next;
 *     public ListNode(int x) { val = x; }
 * }
 */
public class Solution {
    public ListNode GetIntersectionNode(ListNode headA, ListNode headB) {
        if(headA == null || headB == null) return null;
        ListNode pA = headA, pB = headB;
        // 在这里第一轮体现在pA和pB第一次到达尾部会移向另一链表的表头, 而第二轮体现在如果pA或pB相交就返回交点, 不相交最后就是null==null
        while(pA != pB) {
            pA = pA == null ? headB : pA.next;
            pB = pB == null ? headA : pB.next;
        }
        return pA;
    }
}

 （3）使两个链表长度相等，循环依次比较

3.用快慢指针获取中间结点

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     public int val;
 *     public ListNode next;
 *     public ListNode(int x) { val = x; }
 * }
 */
public class Solution {
    public ListNode MiddleNode(ListNode head) {
        ListNode slow=head;
        ListNode fast=head;
        if(head!=null)
        {
        while(fast!=null&&fast.next!=null)
            {
                slow=slow.next;
                fast=fast.next.next;
            }
        }
        
        return slow;
    }
}

通过找到中间结点的方法，也可以借此判断该链表是否是回文

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     public int val;
 *     public ListNode next;
 *     public ListNode(int x) { val = x; }
 * }
 */
public class Solution {
    public bool IsPalindrome(ListNode head) {
        ListNode slow = head;
            ListNode fast = head;
            ListNode temp = head;
            while(fast!=null&&fast.next!=null)
            {
                slow = slow.next;
                fast = fast.next.next;
            }
            slow = ReverseList(slow);
            while(slow!=null)
            {
                if (temp.val != slow.val)
                    return false;
                else
                {
                    temp = temp.next;
                    slow = slow.next;
                }
            }
            return true;
    }
    public ListNode ReverseList(ListNode head) {
        ListNode prev = null; 
        ListNode curr = head; 
        while (curr != null) {
            ListNode nextTemp = curr.next; 
            curr.next = prev; 
            prev = curr;
            curr = nextTemp;
        }
        return prev;
    }
}