四、两两交换链表中的节点删除链表的倒数第N个节点链表相交环形链表II-CSDN博客

本文链接：https://blog.csdn.net/m0_73369512/article/details/135061622

两两交换链表中的节点

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

解法：

fistNode：保存后一节点
secondNode：保存后二节点

使用虚拟头节点，不然头节点还要单独处理

public ListNode swapPairs(ListNode head) {
    ListNode dummy = new ListNode(-1, head);
    ListNode cur = dummy;
    ListNode firstNode;
    ListNode secondNode;
    while (cur.next != null && cur.next.next != null) {
        firstNode = cur.next;
        secondNode = cur.next.next;

        cur.next = secondNode;
        firstNode.next = secondNode.next;
        secondNode.next = firstNode;
        cur = firstNode;
    }
    return dummy.next;
}

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

题目链接：力扣（LeetCode）官网 - 全球极客挚爱的技术成长平台

文章链接：代码随想录

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

解法：

自己的解法：

fast移动直至链表末尾，统计链表的个数，链表节点为n，此时统计数count为n+1
slow移动count-n-1步，指向删除节点的前一个节点

public ListNode removeNthFromEnd(ListNode head, int n) {
    if (head == null) return null;
    ListNode dummy = new ListNode(-1, head);
    ListNode slow = dummy;
    ListNode fast = head;
    int count = 0;
    while (fast != null) {
        fast = fast.next;
        count++;
    }
    for (int i = 0; i < count - n; i++) {
        slow = slow.next;
    }
    slow.next = slow.next.next;
    return dummy.next;
}

题解：

fast移动n步，让fast喝slow同时移动，直至fast指向链表末尾

fast和slow指向虚拟头节点，fast先走n+1步，只有这样同时移动时slow才能指向删除节点的上一个节点

public ListNode removeNthFromEnd(ListNode head, int n) {
    if (head == null) return head;
    ListNode dummy = new ListNode(-1, head);
    ListNode slow = dummy;
    ListNode fast = dummy;
    for (int i = 0; i <= n; i++) {
        fast = fast.next;
    }
    while (fast != null) {
        fast = fast.next;
        slow = slow.next;
    }
    slow.next = slow.next.next;
    return dummy.next;
}

链表相交

题目链接：力扣（LeetCode）官网 - 全球极客挚爱的技术成长平台

文章链接：代码随想录

public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
    int lenA = 0;
    int lenB = 0;
    ListNode curA = headA;
    ListNode curB = headB;
    while (curA != null) {
        curA = curA.next;
        lenA++;
    }
    while (curB != null) {
        curB = curB.next;
        lenB++;
    }
    curA = headA;
    curB = headB;
    if (lenA < lenB) {
        ListNode tempNode = curA;
        curA = curB;
        curB = tempNode;
        int tempLen = lenA;
        lenA = lenB;
        lenB = tempLen;
    }
    int gap = lenA - lenB;
    while (gap-- > 0) {
        curA = curA.next;
    }
    while (curA != null) {
        if(curA == curB) {
            return curA;
        }
        curA = curA.next;
        curB = curB.next;
    }
    return null;
}

误点

节点数值相等 != 节点相等
不能两个同时从头遍历，因为两个链表的长度不一致，所以要先计算出两个链表长度差值，把指向较长链表的指针移动差值个单位，使得两个指针所要移动的单位数相同，可以两边同时遍历，找到初始相交处

环形链表Ⅱ

题目链接：力扣（LeetCode）官网 - 全球极客挚爱的技术成长平台

文章链接：代码随想录

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

双指针解法：

难点

如果有环，如何找到环的入口？

使用快慢指针，慢指针一次移动一个单位，快指针一次移动两个单位，即快指针相较于快指针一次移动一个单位，快指针先进入到环内，当慢指针进入到环内后，快指针追上慢指针时至少绕了一圈，而快指针相较于慢指针一次只移动一个单位，则慢指针与快指针一定会相遇而不会错过。具体推理文章里有。

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