双指针解决链表问题

1. 快慢指针找链表中点

使用快慢指针在一次遍历中找到：慢指针一次走一步，快指针一次走两步，快慢指针同时出发。当快指针移动到链表的末尾时，慢指针到链表的中间。通过慢指针将链表分为两部分

 private ListNode endOfFirstHalf(ListNode head) {
        ListNode fast = head;
        ListNode slow = head;
        while (fast.next != null && fast.next.next != null) {
            fast = fast.next.next;
            slow = slow.next;
        }
        return slow;
    }

2. 利用双指针找两个单链表相交的起始节点

如果两个链表相交，那么相交点之后的长度是相同的

我们需要做的事情是，让两个链表从同距离末尾同等距离的位置开始遍历。
为此，我们必须消除两个链表的长度差

① 指针 pA 指向 A 链表，指针 pB 指向 B 链表，依次往后遍历
② 如果 pA 到了末尾，则 pA = headB 继续遍历
③ 如果 pB 到了末尾，则 pB = headA 继续遍历
④ 比较长的链表指针指向较短链表head时，长度差就消除了，因为如图而言，pA会比pB早1步遍历完，之后指向B的头节点，pB再走一步后再指向A的头节点，这个时候pA和pB就是从同距离末尾同等距离的位置开始遍历

如此，只需要将最短链表遍历两次即可找到位置

public class Solution {
    public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
        ListNode pa = headA;
        ListNode pb = headB;
        while(pa!=pb){
            pa = pa==null? headB:pa.next;
            pb = pb==null? headA:pb.next;
            //下面这样是不对的 因为无法判空
            //pa = pa.next==null?headB:pa.next;
            //pb = pb.next==null?headA:pb.next;
        }
        return pa;
    }
}

3. 双指针判断环形链表

通过使用具有 不同速度 的快、慢两个指针遍历链表，空间复杂度可以被降低至 O(1)。慢指针每次移动一步，而快指针每次移动两步。

如果列表中不存在环，最终快指针将会最先到达尾部，此时我们可以返回 false

public boolean hasCycle(ListNode head) {
    if (head == null || head.next == null) {
        return false;
    }
    ListNode slow = head;
    ListNode fast = head.next;
    while (slow != fast) {
        if (fast == null || fast.next == null) {
            return false;
        }
        slow = slow.next;
        fast = fast.next.next;
    }
    return true;
}

4. 利用双指针实现一次遍历删除链表的倒数第 n 个节点

我们可以设想假设设定了双指针 p 和 q 的话，当 q 指向末尾的 NULL，p 与 q 之间相隔的元素个数为 n 时，那么删除掉 p 的下一个指针就完成了要求。

设置虚拟节点 dummyHead 指向 head
设定双指针 p 和 q，初始都指向虚拟节点 dummyHead
移动 q，直到 p 与 q 之间相隔的元素个数为 n
同时移动 p 与 q，直到 q 指向的为 NULL
将 p 的下一个节点指向下下个节点

public ListNode removeNthFromEnd(ListNode head, int n) {
    ListNode dummy = new ListNode(0);
    dummy.next = head;
    int length  = 0;
    ListNode first = head;
    while (first != null) {
        length++;
        first = first.next;
    }
    length -= n;
    first = dummy;
    while (length > 0) {
        length--;
        first = first.next;
    }
    first.next = first.next.next;
    return dummy.next;
}

5. 反转单链表

    /**
     * 递归
     */
    public ListNode reverseList(ListNode head) {
        if (head == null || head.next == null)
            return head;
        ListNode nextNode = head.next;
        ListNode newHead = reverseList(nextNode);
        nextNode.next = head;
        head.next = null;
        return newHead;
    }
     /**
     * 迭代
     */
    public ListNode reverseList2(ListNode head) {
        ListNode pre = null;                  //存上一个节点
        while (head != null) {
            ListNode current = head;
            head = head.next;
            current.next = pre;
            pre = current;
        }
        return pre;
    }