代码随想录算法训练营第四天 | 24.两两交换链表中的节点、19. 删除链表的倒数第 N 个结点、面试题 02.07. 链表相交

题解

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

• 思路：正好联想到了第三天的反转链表，同样操作2个节点，同样为交换。
• 解法：双指针法

class Solution {
public:
    ListNode* swapPairs(ListNode* head) {
        if (head == nullptr || head->next == nullptr) return head;
        ListNode* dummy = new ListNode(0,head);
        ListNode* p = dummy;
        ListNode* low;
        ListNode* fast;
        ListNode* tmp;
        while (p->next != nullptr && p->next->next != nullptr) { // 同时满足：双数元素
            low = p->next;
            fast = low->next;
            p->next = fast;
            tmp = fast->next;
            fast->next = low;
            low->next = tmp;
            p = low;
        }
        return dummy->next;
    }
};

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

• 思路：来源于 707.设计链表中的addAtIndex函数逻辑，确定节点用index，如今知道倒数第几n，用index = size-n得到待删除节点。
• 不过没实现 一遍扫描 ，不过整合一下应该就可以：统计节点和确定待删除节点同时进行，有时间再做。

class Solution {
public:
    ListNode* removeNthFromEnd(ListNode* head, int n) {
        if (head->next == nullptr) return head->next;
        ListNode* p = head;
        int size = 0;
        while (p != nullptr) {
            size++;
            p = p->next;
        }
        int index = size - n;
        if (index == 0) {
            head = head->next;
            return head;
        } 
        p = head;
        ListNode* pre;
        while (index--) {
            pre = p;
            p = p->next;
        }
        pre->next = p->next;
        delete p;
        return head;
    }
};

面试题 02.07. 链表相交

• 思路：双重循环是暴力解，想要一种O(n)级别的。那就要将两个链表对齐同步对比，因此有了 节点个数作差->长的链表遍历到与短的对齐->同步遍历 的解法。

class Solution {
public:
    ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
        if (headA == nullptr || headB == nullptr) return nullptr;
        ListNode* p = headA;
        int sizeA = 0;
        while (p != nullptr) {
            sizeA++;
            p = p->next;
        }
        p = headB;
        int sizeB = 0;
        while (p != nullptr) {
            sizeB++;
            p = p->next;
        }
        int index = sizeA - sizeB;
        p = headA;
        ListNode* q = headB;
        if (index > 0) {
            while (index--) {
                p = p->next;
            }
        }
        else {
            while (index != 0) {
                q = q->next;
                index++;
            }
        }
        while(p != q) {
            p = p->next;
            q = q->next;
        }
        if (p != nullptr) {
            return p;
        }
        return nullptr;
    }
};