代码随想录算法训练营-day04-24. 两两交换链表中的节点、19.删除链表的倒数第N个节点、面试题 02.07. 链表相交、142.环形链表II

24. 两两交换链表中的节点

1. 学习文章链接：
2. 代码分析：
   1. 代码的主体结构基于翻转链表的代码。
   2. 设计虚拟头节点，方便翻转
   3. 严格按照三步走逻辑，cur为虚拟头节点。

3. 代码

class Solution {
    public ListNode swapPairs(ListNode head) {
        if (head == null || head.next == null) return head;
        ListNode dummy = new ListNode(0);
        dummy.next = head;
        ListNode cur = dummy;
        while (cur.next != null && cur.next.next != null) {
            ListNode temp1 = cur.next;
            ListNode temp2 = cur.next.next.next;

            cur.next = cur.next.next;
            cur.next.next = temp1;
            temp1.next = temp2;
            cur = temp1;
        }
        return dummy.next;
    }
}

4. 心得：
   1. 想要做好此题，最好先熟练反转链表的原理的代码实现，然后这道题就迎刃而解了
   2. 个人认为这道题的难点在于对next指针的理解，很有可能next一多，就被绕懵。
   3. 特殊说明：关于暂存节点temp，个人认为是给该节点打上了标识 ，避免反转过程中，导致节点的丢失。

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

1. 学习文章链接：
2. 题目分析：
   1. 同样使用虚拟头节点来解决，目的是让头节点可以使用统一方法处理。
   2. 为什么fast走了n+1步？
      1. 需要删除一个节点，则必须找到其上一个节点，而不是当前节点，删除节点的上一个节点的位置就是倒数n+1处的节点。
      2. fast指针先走n+1步，目的就是让fast指针与slow指针之间的间距为n+1步，那么但fast指针走到null时（注意此位置也是出循环的判定条件），slow指针自然走到了倒数n+1的位置。
   3. 然后倒数n位置的节点删掉。
3. 代码：

/**
 * 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) {
        if (head == null || head.next == null) return null;
        ListNode dummy = new ListNode(0); //创建虚拟头节点
        dummy.next = head;  //将虚拟头节点连接到原有链表
        ListNode fast = dummy;
        ListNode slow = dummy;

        for (int i = 0; i < n + 1; i++) {
            fast = fast.next;
        }
        while (fast != null) {
            fast = fast.next;
            slow = slow.next;
        }
        slow.next = slow.next.next;
        return dummy.next;
    }
}

4. 心得：
   1. 对n+1有了更深刻的理解。
   2. 一步一步加深对链表的理解。

面试题 02.07. 链表相交

1. 学习文章链接：
2. 题目分析：
   1. 链表相交前提是没有环形链表。
   2. 相等是节点相等，不是节点的值相等。
   3. 将两条链表的末尾对齐。
   4. 因此较长的链表就需要先走到与较短链表相同起始位置的地方。
   5. 如果相同，则返回，不相同则一起遍历列表，直到遍历结束。
3. 代码：

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) {
 *         val = x;
 *         next = null;
 *     }
 * }
 */
public class Solution {
    public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
        if (headA == null || headB == null) return null;
        ListNode curA = headA;
        ListNode curB = headB;
        int lenA = 1;
        int lenB = 1;
        while (curA != null) {
            curA = curA.next;
            lenA++;
        }
        while (curB != null) {
            curB = curB.next;
            lenB++;
        }
        curA = headA;
        curB = headB;
        if (lenA < lenB) {
            ListNode temp = curA;
            curA = curB;
            curB = temp;
            int tempNum = lenA;
            lenA = lenB;
            lenB = tempNum;
        }
        int gap = lenA - lenB;
        for (int i = 0; i < gap; i++) {
            curA = curA.next;
        }
        while (curA != null) {
            if (curA == curB) {
                return curA;
            }
            curA = curA.next;
            curB = curB.next;
        }
        return null;
    }
}

4. 心得：
   1. 遍历长度之后，重新将指针指向头节点。
   2. 还是要多注意细节。

142.环形链表II

1. 学习文章链接：
2. 题目分析：
   1. 关键点拆分：是否有环、环的入口在哪里
   2. 如何判断有环：使用双指针法，分别为快指针（一次走两个节点）、慢指针（一次走一个节点）。在非环阶段，fast指针会将slow指针抛在后面。如果存在环，那么进环后，就变成了先进环的fast指针在追赶slow指针，可以理解成跑步中的即将扣圈行为。由于二者的步长差为1，那么二者之间的距离以每次一个节点的速度缩小，slow指针终究会被fast指针追赶上，即二者相等。当二者相等时，必然存在环。
   3. 环的入口求解：
      1. 相遇时，slow走的节点数为x+y，fast指针走的节点数为x+y+n*(y+z)，有的同学可能会疑惑为什么slow指针没有走完完整的一圈呢？假设slow走了完整的一圈，那么fast必然走了完整的两圈，那么在步长差为1的情况，fast是一定会遇到slow的。
      2. 因为slow的步长为一个节点，fast为两个节点，那么fast走的总结点数应该是slow走的总节点数的2倍。因此有2(x+y) = x+y+n*(y+z)，我们可以发现x，即为我们所求的节点入口处。
      3. 简化得 x = (n - 1)(y + z) + z，至此环的入口就求解出来了。
   4. 在实际的代码实现中，我们只要分别在head节点和fast节点出发两个指针，当两个指针到达同一节点时，即找到环形入口。

3. 代码：

public class Solution {
    public ListNode detectCycle(ListNode head) {
        ListNode fast = head;
        ListNode slow = head;
        while (fast != null && fast.next != null) {
            fast = fast.next.next;
            slow = slow.next;
            if (fast == slow) {
                ListNode index1 = fast;
                ListNode index2 = head;
                while (index1 != index2) {
                    index1 = index1.next;
                    index2 = index2.next;
                }
                return index1;
            }
        }
        return null;
    }
}

4. 心得：
   1. 巧妙利用公式推理解答该问题。