day4 | 24 两两交换链表中的节点,19 删除链表的倒数第N个节点,142 环形链表II,02 07 链表相交

24 两两交换链表中的节点

题意是两两交换，而不是相邻交换

思路

设置一个虚拟头节点，并将指针cur指向虚拟头节点
要考虑直到什么时候停止交换，如果链表个数是偶数个的话，cur.next != null 。如果是奇数个的话，cur.next.next != null。
并且cur.next != null 判断在前，cur.next.next != null 的判断在后，因为cur.next.next先执行的话，如果当cur.next就等于null的话，就会
报空指针异常。
同时，在遍历的时候要注意提前保存节点。

题解

class Solution {
  public ListNode swapPairs(ListNode head) {
        ListNode dumyhead = new ListNode(-1); // 设置一个虚拟头结点
        dumyhead.next = head; // 将虚拟头结点指向head，这样方面后面做删除操作
        ListNode cur = dumyhead;
        ListNode temp; // 临时节点，保存两个节点后面的节点
        ListNode firstnode; // 临时节点，保存两个节点之中的第一个节点
        ListNode secondnode; // 临时节点，保存两个节点之中的第二个节点
        while (cur.next != null && cur.next.next != null) {
            temp = cur.next.next.next;
            firstnode = cur.next;
            secondnode = cur.next.next;
            cur.next = secondnode;       // 步骤一
            secondnode.next = firstnode; // 步骤二
            firstnode.next = temp;      // 步骤三
            cur = firstnode; // cur移动，准备下一轮交换
        }
        return dumyhead.next;  
    }
}

困难

cur = firstnode;还没有理解，保存这个问题，回头再看。

19 删除链表的倒数第N个节点

思路

设置虚拟头节点和两个指针slow,fast，初始指向虚拟头节点。
要删除倒数第n个数，则先让fast移动n+1次，再在fast.next != null的条件下，slow和fast同步移动。
最后slow会指向要删除的节点的前一个位置，fast会指向null

题解

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    public ListNode removeNthFromEnd(ListNode head, int n){
        ListNode dummyNode = new ListNode(0);
        dummyNode.next = head;

        ListNode fastIndex = dummyNode;
        ListNode slowIndex = dummyNode;

        //只要快慢指针相差 n 个结点即可
        for (int i = 0; i < n  ; i++){
            fastIndex = fastIndex.next;
        }

        fastIndex = fastIndex.next;

        while (fastIndex != null){
            fastIndex = fastIndex.next;
            slowIndex = slowIndex.next;
        }

        //此时 slowIndex 的位置就是待删除元素的前一个位置。
        //具体情况可自己画一个链表长度为 3 的图来模拟代码来理解
        slowIndex.next = slowIndex.next.next;
        return dummyNode.next;
    }
}

困难

当fast指向最后一个节点，而不是null的时候，while判断条件是fast.next != null, 此时fast移动了n次而不是n+1次，
这样，slow指向的也是要删除节点的前一个位置。

02 07 链表相交

思路

求出两个链表的长度，并求出两个链表长度的差值，然后让curA移动到和curB末尾对齐的位置
此时我们就可以比较curA和curB是否相同，如果不相同，同时向后移动curA和curB，如果遇到
curA == curB, 则找到交点。否则循环退出返回空指针。

题解

public class Solution {
    public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
        ListNode curA = headA;
        ListNode curB = headB;
        int lenA = 0, lenB = 0;
        while (curA != null) { // 求链表A的长度
            lenA++;
            curA = curA.next;
        }
        while (curB != null) { // 求链表B的长度
            lenB++;
            curB = curB.next;
        }
        curA = headA;
        curB = headB;
        // 让curA为最长链表的头，lenA为其长度
        if (lenB > lenA) {
            //1. swap (lenA, lenB);
            int tmpLen = lenA;
            lenA = lenB;
            lenB = tmpLen;
            //2. swap (curA, curB);
            ListNode tmpNode = curA;
            curA = curB;
            curB = tmpNode;
        }
        // 求长度差
        int gap = lenA - lenB;
        // 让curA和curB在同一起点上（末尾位置对齐）
        while (gap-- > 0) {
            curA = curA.next;
        }
        // 遍历curA 和 curB，遇到相同则直接返回
        while (curA != null) {
            if (curA == curB) {
                return curA;
            }
            curA = curA.next;
            curB = curB.next;
        }
        return null;
    }

}

142 环形链表II

判断环

首先设置两个指针fast,和slow
fast指针每次走两步，slow指针每次走一步
如果链表有环，那么fast会先进入环，然后slow后进入。当两个指针都在环里时，两个指针的状态为
fast会去追slow, 如果fast追上slow,即fast和slow相遇，那么判断这个链表有环
问题：
为什么fast走两步而不是三步。
答：fast走两步时，slow是走一步，即fast相对slow来说，是走一步，即两个指针在相遇时，fast是一步一步去追的，如果有环，那么肯定会相遇。如果fast走三步甚至更多，那slow还是走一步的话，fast可能会跳过slow，fast可能永远也遇不到slow.

找出环的入口

设起点到环入口的距离为x, 环入口到fast和slow相遇的距离为y, 相遇位置到环入口的距离为z
slow = x + y
fast = x + y + n(y + z)
因为fast在遇到slow时已经在环里转了至少一圈，所以fast = x + y + n(y + z)
又因为fast比slow多走1步，所以有如下等式：
2slow = fast
即：2(x + y) = x + y + n(y + z)
x + y = n(y + z)
x = n(y + z) - y
因为x与-y的关系不好处理，所以消掉-y
那么 x = (n - 1)(y + z) + z
因为n 表示 fast在环里转了几圈，所以为了方便，可以让 n = 1,
那么 x = z
所以我们可以设 相遇位置为 index1, 起始位置为index2
index1 和 index2同时移动，他们相遇的点为环的入口处

题解

public class Solution {
    public ListNode detectCycle(ListNode head) {
        ListNode slow = head;
        ListNode fast = head;
        while (fast != null && fast.next != null) {
            slow = slow.next;
            fast = fast.next.next;
            if (slow == fast) {// 有环
                ListNode index1 = fast;
                ListNode index2 = head;
                // 两个指针，从头结点和相遇结点，各走一步，直到相遇，相遇点即为环入口
                while (index1 != index2) {
                    index1 = index1.next;
                    index2 = index2.next;
                }
                return index1;
            }
        }
        return null;
    }
}