04| ● 24. 两两交换链表中的节点 ● 19.删除链表的倒数第N个节点 ● 面试题 02.07. 链表相交 ● 142.环形链表II

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

在对链表节点进行操作时，一定要注意每断开一个连接，就要在断开前预存地址，以免后续的逻辑混乱。

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;  
    }
}

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

题目链接

这里使用快慢指针找到倒数第n个节点的位置，当快指针先走n步后，快慢指针一起移动，这样当快指针指向null时，慢指针就指向了倒数第N个节点。

要注意慢指针需指向被删除节点的前一节点，所以快指针还要再多走一步

注意循环判断条件中的逻辑，是短路与还是短路或

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;
    }

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

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

链表相交

题目链接

当两条链表不等长时，可以通过先靠后对齐的方式，再将指针指向前面开始等长的位置，然后一一遍历找到相交的点寻找相交的节点时，应该检查curA是否等于curB，而不是检查curA.next是否等于curB.next，反例：【1】，【1】

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;
    }

}

环形链表

题目链接

这里需要先判断链表是否有环，然后在有环时去寻找环的入口。

通过快慢指针把有无环的判断问题转换为追及问题，如果快指针会跑到null，则无环，如果快慢指针会相遇，则有环

这里需要一些数学过程，可以得到，慢指针在第一圈就和快指针相遇，且相遇的节点到环入口的距离等于头节点到环入口的距离。卡哥在B站视频里画图分析的很清楚，环形链表

fast的移动速度是2，while的循环判断条件要搞清楚是判断哪两个节点，以避免空指针异常

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;
    }
}

碎碎念

感觉个别题目的难度开始上升，但还是会为自己独立思考出任何一点点的思路而兴奋，尤其是在独立写出题目时，成就感满满。在写环形链表的题时，很佩服解题思路的精妙，一定要坚持下去，“我亦无他，唯手熟尔”