代码随想录算法训练营第四天| LeetCode24. 两两交换链表中的节点、LeetCode19.删除链表的倒数第N个节点、LeetCode160.链表相交、LeetCode142.环形链表II

#LeetCode 24. Swap Nodes in Pairs

#LeetCode 24. 视频讲解：帮你把链表细节学清楚！ | LeetCode：24. 两两交换链表中的节点_哔哩哔哩_bilibili

首先建立虚拟头节点，方便处理前两个节点的交换，注意cur 指针应该指向交换节点的前一个节点，所以下图中橙色矩形代表的是指针cur 应该指向的位置（不是节点，如果交换后依然是同样的位置，但不再是原节点）。

交换的步骤：首先cur 指针遍历到交换节点的前一位，新建两个临时变量temp 和temp1 保存1 节点和 3 的节点（防止在cur.next = cur.next.next 后找不到1 节点）。当前节点下一位是2 的节点（step 1），2 的节点的下一位是1 的节点（step 2），完成了交换，第三步是将原来是1 的节点与余下节点连接起来（step 3），交换完应为右下角的顺序，cur 指针应该移动到图中目前标号为1 节点的位置，来交换原图中3 节点和4 节点。

虚拟头节点方法： 时间复杂度O(n).

/**
 * 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 swapPairs(ListNode head) {
        ListNode dummy_head = new ListNode (-1, head);
        ListNode cur = dummy_head;
        ListNode temp;
        ListNode temp_1;
        while (cur.next != null && cur.next.next != null) {
            temp = cur.next;
            temp_1 = cur.next.next.next;
            cur.next = cur.next.next; // step 1: dummy_head, 2
            cur.next.next = temp; // step 2: dummy_head, 2, 1
            temp.next = temp_1; // step 3: dummy_head, 2, 1, 3
            cur = cur.next.next;
        }
        return dummy_head.next;
    }
}

#LeetCode 19. Remove Nth Node From End of List

#LeetCode 19. 视频讲解： 链表遍历学清楚！ | LeetCode：19.删除链表倒数第N个节点_哔哩哔哩_bilibili

题目需要考虑如何移动到链表的倒数第N 个节点位置，建立两个指针fast 指针和slow 指针，fast 指针首先移动长度N （其实是N+1 个长度，设置条件为：当N > 0时），之后slow 指针和fast 指针同时向后移动，直到fast 指针指向null，那么slow 指针刚好指向倒数第N 个元素。可以理解为fast 指针和slow 指针建立了一个长度为N 的窗口，一直以这个长度向后移动，当fast 指针指向null 时，slow 指向的即为倒数第N 个节点。细节是N 先自加，因为建立了dummy_head 节点以及需要指向被删除节点的前一位（如下图）。

建立虚拟头节点方法： 时间复杂度O(n).

/**
 * 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 (n < 0) {
            return head;
        }
        ListNode dummy_head = new ListNode(-1, head);
        ListNode fast = dummy_head;
        ListNode slow = dummy_head;
        n++;
        while (n > 0 && fast != null) {
            fast = fast.next;
            n--;
        }
        while (fast != null) {
            slow = slow.next;
            fast = fast.next;
        }
        slow.next = slow.next.next;
        return dummy_head.next;
    }
} 

#LeetCode 160.  Intersection of Two Linked Lists

#LeetCode 160. 文字讲解：代码随想录

回顾链表节点定义：每个节点包含两部分，节点的值val 和指向下一个节点的指针next 。所以意味着从相交点开始，两个链表后续的节点是完全相同的，包括节点的值和节点的顺序。

交换两个链表是为了使用cur_a 指向长链表，如果不想交换，也可以分count_a > count_b 和count_a < count_b两种情况来考虑。长链表的指针需要移动到与短链表对齐时开始比较，才可以保证在第N 个节点后相等。​​​​​​​

代码如下： 

/**
 * 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) {
        int count_a = 0, count_b = 0;
        ListNode cur_a = headA;
        ListNode cur_b = headB;
        while (cur_a != null) {
            count_a++;
            cur_a = cur_a.next;
        }
        while (cur_b != null) {
            count_b++;
            cur_b = cur_b.next;
        }
        int diff = 0;
        cur_a = headA;
        cur_b = headB;
        if (count_b > count_a) {
            int tmpLen = count_a;
            count_a = count_b;
            count_b = tmpLen;
            ListNode tmpNode = cur_a;
            cur_a = cur_b;
            cur_b = tmpNode;
        }
        diff = count_a - count_b;
        while (diff > 0) {
            cur_a = cur_a.next;
            diff--;
        }
        while (cur_a != null) {
            if (cur_a == cur_b) {
                return cur_a;
            }
            cur_a = cur_a.next;
            cur_b = cur_b.next;
        }
        return null;
    }
}

#LeetCode 142. Linked List Cycle II

#LeetCode 142. 视频讲解：把环形链表讲清楚！ 如何判断环形链表？如何找到环形链表的入口？ LeetCode：142.环形链表II_哔哩哔哩_bilibili

环形链表考虑使用双指针，如果存在环形，那么快指针可以追到慢指针 ，如果没有环，那么快指针最终会到达链表的末尾（null ）。假设快指针每次走2 个节点，慢指针每次走1 个节点，在环中，快指针和满指针的速度差为1 ，一定不会跳过慢指针且会在环中追到慢指针（如果速度差为2，那么有可能跳过了慢指针）。下图的直线部分x 代表不成环部分，s 代表快慢指针走过的路程，v 代表各指针速度，如果相遇则代表时间相同，根据等式关系可以列出下图公式。

可以化简得到x = (n - 1) (y + z) + z.如果n = 1 ，意味着快指针比慢指针多走了一圈，就追到了慢指针，此时x = z，可以根据这个公式写出代码，当快慢指针第一次相遇后，在相遇点和起点以相同速度前进，再次相遇的点为环形链表的起点。

具体代码如下： 

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