【算法-链表3】删除链表倒数第n个节点 + 链表相交

今天，带来XXX的讲解。文中不足错漏之处望请斧正！

理论基础点这里

---

删除链表倒数第n个节点

1. 思路

直接计算

倒数第n个 = 正数第size-n+1个

比如要删除size为5的链表的倒数第2个节点。

其实就是正数size-n+1个。那么，从第一个走到底size-n+1个需要几步呢？恰好是size-n步。

当然，这不符合题目进阶的要求，我们仅仅是获取大小就已经扫描了一遍链表。而我们扫描完，计算要走的步数后，还要进行扫描。

双指针法

快指针先走n步，而后快慢指针一起走：当快指针为空，慢指针恰好指向倒数第n个节点。

是怎么想到的呢？

倒数的本质不就是结尾和某个位置的距离嘛：倒数第2个，即距离结尾的null有2步的距离；倒数第3个即距离结尾的null有3步的距离。

那我们要删除slow（图中的4），要能找到3。怎么做呢？找要删除的节点的前一个即可！

我们给一个虚拟头结点dummyHead，slow和fast从dummyHead开始，这样当fast→next为空的时候，slow指向倒数第n个节点的前一个。

2. 参考代码

class Solution {
public:
    int getSize(ListNode *head) {
        int size = 0;
        while (head != nullptr) {
            head = head->next;
            ++size;
        }
        return size;
    }

    ListNode* removeNthFromEnd(ListNode* head, int n) {
        ListNode *dummyHead = new ListNode(-1, head);
        ListNode *cur = head;

        // 找到倒数第n个结点, 即正数第 size-n+1 个结点
        // 从第一个节点走到正数第 size-n+1 个节点只需要 size-n 步
        int steps = getSize(head) - n;
        // 找要删除的节点的前一个位置, 所以从head的前一个开始找
        cur = dummyHead;
        for (int i = 0; i < steps; ++i) cur = cur->next; 
        ListNode *dying = cur->next;
        cur->next = cur->next->next; // 1 <= n <= sz 所以不会访问空指针
        delete dying;

        head = dummyHead->next;
        delete dummyHead;
        return head;
    }
};

class Solution {
public:
    ListNode *removeNthFromEnd(ListNode *head, int n) {
        ListNode *dummyHead = new ListNode(-1, head);
        ListNode *slow = dummyHead;
        ListNode *fast = dummyHead;

        for (int i = 0; i < n; ++i) fast = fast->next; // 先走n步
        while (fast->next != nullptr) { // 一起走
            slow = slow->next;
            fast = fast->next;
        }

        ListNode *dying = slow->next;
        slow->next = slow->next->next; // 删除节点
        delete dying;

        head = dummyHead->next;
        delete dummyHead;
        return head;
    }
};

---

链表相交

1. 思路

我们想直接遍历两个head是行不通的，因为长度不一定相同，可能链表本身相交，但两个head错过了。所以可以先同步，这样同时遍历两个head就能找到相交节点了。

消除长度差后，既可以直接判断两指针本身，也可以判断两指针的下一个位置。

2. 参考代码

class Solution {
public:
    ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
        // 1. 计算长度差gap
        int sizeA = getSize(headA);
        int sizeB = getSize(headB);
        int gap = abs(sizeA - sizeB);

        // 2. 长的链表先走gap步 -- 二表长度相同
        ListNode *&longList = sizeA > sizeB ? headA : headB;
        while (gap--) longList = longList->next;

        // 3. 二表同时走, 走某步时两表指针指向同一个元素就表示链表在此处相交
        while (headA != nullptr) {
            if (headA == headB) return headA;
            headA = headA->next;
            headB = headB->next;
        }

        return nullptr;
    }
private:
    int getSize(ListNode *head) {
        int size = 0;
        while (head != nullptr) {
            head = head->next;
            ++size;
        }
        return size;
    }
};

---

今天的分享就到这里了，感谢您能看到这里。

这里是培根的blog，期待与你共同进步！