剑指Offer | day12_双指针

2021/10/4 | 占坑+2
我是菜鸡我是菜鸡我是菜鸡
如果骂自己有用的话。

剑指 Offer 25. 合并两个排序的链表

输入两个递增排序的链表，合并这两个链表并使新链表中的节点仍然是递增排序的。

示例1：

输入：1->2->4, 1->3->4
输出：1->1->2->3->4->4

限制：

0 <= 链表长度 <= 1000

方法：双指针

class Solution {
public:
    ListNode* mergeTwoLists(ListNode* l1, ListNode* l2) { 
        ListNode* head = new ListNode(-1);
        ListNode* rear = head;

        while(l1 != NULL && l2 != NULL) {
            if(l1->val < l2->val) {
                rear->next = l1;
                l1 = l1->next;
            }
            else {
                rear->next = l2;
                l2 = l2->next;
            }
            rear = rear->next;
        }

        if(l1 != NULL) {
            rear->next = l1;
        }
        if(l2 != NULL) {
            rear->next = l2;
        }

        return head->next;
    }
};

• 时间复杂度：O(M+N)
• 空间复杂度：O(1)

剑指 Offer 52. 两个链表的第一个公共节点

输入两个链表，找出它们的第一个公共节点。

如下面的两个链表：

在节点 c1 开始相交。

示例 ：

输入：intersectVal = 8, listA = [4,1,8,4,5], listB = [5,0,1,8,4,5], skipA = 2, skipB = 3
输出：Reference of the node with value = 8
输入解释：相交节点的值为 8 （注意，如果两个列表相交则不能为 0）。从各自的表头开始算起，链表 A 为 [4,1,8,4,5]，链表 B 为 [5,0,1,8,4,5]。在 A 中，相交节点前有 2 个节点；在 B 中，相交节点前有 3 个节点。

注意：

• 如果两个链表没有交点，返回 null.
• 在返回结果后，两个链表仍须保持原有的结构。
• 可假定整个链表结构中没有循环。
• 程序尽量满足 O(n) 时间复杂度，且仅用 O(1) 内存。

方法一：哈希表

class Solution {
public:
    ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
        // 将链表A加入哈希表
        unordered_map<ListNode*, int> map; 
        ListNode* p = headA;
        while(p != NULL) {
            if(!map.count(p)) {
                map[p] = 1;
            }
            p = p->next;
        }
        // 遍历链表B
        ListNode* q = headB;
        while(q != NULL) {
            if(map.count(q)) {
                return q;
            }
            q = q->next;
        } 
        return NULL;
    }
};

• 时间复杂度：O(n)
• 空间复杂度：O(n)

方法二：双指针

思路：意想不到的双指针，根据len(A) + len(B) == len(B) + len(A)可知，如果存在交点的话，两个指针循环完本链表后，接着循环另一条链表，是一定会结束在同一个节点的。如果不存在交点的话，两个指针会同时循环完两条链表，并且同时指向NULL

class Solution {
public:
    ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
        if(headA == NULL || headB == NULL) {
            return NULL;
        }

        ListNode *node1 = headA;
        ListNode *node2 = headB;

        while(node1 != node2) {
            node1 = (node1 == NULL) ? headB : node1->next;
            node2 = (node2 == NULL) ? headA : node2->next;
        }
        return node1;
    }
};

• 时间复杂度：O(n)
• 空间复杂度：O(1)