Day4 | LeetCode 24. 两两交换链表中的节点、19. 删除链表的倒数第 N 个结点面试题、 02.07. 链表相交、142. 环形链表 II、链表的难点及总结

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

两两交换链表老是犯错，不是判断条件出错，就是节点更新的操作又出错。其实发现如果把步骤想明白，一步一步模型就可以。
按照代码随想录上解法的步骤一、二、三。就没问题。

/**
 * 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) {

        if (head == null || head.next == null) {
            return head;
        }
        
        ListNode dummy = new ListNode(0, head);

        ListNode cur = dummy, nodeA = head, nodeB = head;
        ListNode temp;

        while (nodeA != null && nodeA.next != null) {
            nodeB = nodeB.next; // 注意这里的处理, nodeB一开始并没有指向第二个节点。

            cur.next = nodeB;   // 步骤一
            temp = nodeB.next;

            nodeB.next = nodeA; // 步骤二
            nodeA.next = temp;  // 步骤三

            cur = nodeA;
            nodeA = cur.next;
            nodeB = nodeA;
        }
        return dummy.next;
    }
}

19. 删除链表的倒数第 N 个结点面试题

class Solution {
    public ListNode removeNthFromEnd(ListNode head, int n) {
        
        ListNode nommy = new ListNode(0, head);
        ListNode last = head, pre = nommy;

        int i = 0;
        while (i < n) {
            last = last.next;
            i++;
        }

        while (last != null) {
            pre = pre.next;
            last = last.next;
        }
        pre.next = pre.next.next;
        return nommy.next;
    }
}

02.07. 链表相交

将链表A和B末尾对齐：计算差值 n，长链表头节点向前移动 n 个位置,后一起遍历寻找共同节点。

public class Solution {
    public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
        // 将链表A和B末尾对齐：计算差值 n，长链表头节点向前移动 n 个位置
        int m = 0, n = 0;
        ListNode nodeA = headA, nodeB = headB;

        while (nodeA != null) {
            m++;
            nodeA = nodeA.next;
        }
        while (nodeB != null) {
            n++;
            nodeB = nodeB.next;
        }
        int sub;
        if (m > n) { // A > B
            sub = m - n;
            nodeA = headA;
            nodeB = headB;
        } else { // B > A
            sub = n - m;
            nodeA = headB;
            nodeB = headA;
        }

        for (int i = 0; i < sub; i++) {
            nodeA = nodeA.next;
        }

        while (nodeA != null) {
            if (nodeA == nodeB) {
                return nodeA;
            }
            nodeA = nodeA.next;
            nodeB = nodeB.next;
        }
        return null;
    }
}

142. 环形链表 II

做过太多遍了，粘一下解析吧
https://programmercarl.com/0142.%E7%8E%AF%E5%BD%A2%E9%93%BE%E8%A1%A8II.html

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 (fast == slow) { // 存在 环
                slow = head;
                while (slow != fast) {
                    slow = slow.next;
                    fast = fast.next;
                }
                return slow;
            }
        }
        return null;
    }
}

链表的难点及总结

对节点的操作和判断是一个难点，做之前一定考虑清楚，否则很容易犯错。
可以先把步骤写出来，严格按照步骤写代码不容易写迷糊。