力扣刷题攻略链表篇-链表的合并

文章内容是自己刷leetcode官方刷题攻略的一些经验与总结。
题目链接详见 leetcode刷题攻略
如果喜欢的话，别忘了点个赞哦 ^ _ ^

一. 21. 合并两个有序链表

1.题目描述

2.题目分析与解答

题目给了我们两个升序列表，我们需要将两个链表中的这些原始节点按照升序重新排列成一个新链表。

可以使用虚拟头节点，利用题目给的双指针遍历链表，比较每次两个指针指向的节点值，按照节点值的大小连接成一个新链表即可。

C++ 代码如下：

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* mergeTwoLists(ListNode* list1, ListNode* list2) {
        //双指针
        //虚拟头节点

        // if(!list1) return list2;
        // if(!list2) return list1;

        ListNode *dummyHead = new ListNode(0, nullptr);
        ListNode *cur = dummyHead;
        while(list1 && list2) {
            if(list1->val > list2->val) {
                cur->next = list2;
                list2 = list2->next;
            } else {
                cur->next = list1;
                list1 = list1->next;
            }

            cur = cur->next;
        }

        if(list1) cur->next = list1;
        if(list2) cur->next = list2;

        cur = dummyHead->next;
        delete(dummyHead);
        return cur;
    }
};

二. 23. 合并 K 个升序链表

1.题目描述

2.暴力遍历

这道题难度其实不大，题目给了我们一个升序的链表数组，要将这些链表重新按照升序排列成一个链表。

我们可以创建一个答案链表，然后遍历链表数组，将链表数组中的每个链表依次与答案链表进行合并两个有序链表的操作，也就是上一道题的方法。

C++ 代码如下：

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* mergeKLists(vector<ListNode*>& lists) {
        //因为上一道题做过了合并两个升序链表
        //这道题我们可以初始化一个答案链表，然后将原始数组中每个链表与其进行合并
        //可以使用分治合并进行时间复杂度优化

        ListNode *ans = nullptr;
        for(int i = 0; i < lists.size(); i ++) {
            ans = mergeTwoList(ans, lists[i]);
        }

        return ans;
    }

    ListNode * mergeTwoList(ListNode *l1, ListNode *l2) {
        //合并两个升序链表
        ListNode *dummyHead = new ListNode(0, nullptr);
        ListNode *cur = dummyHead;
        while(l1 && l2) {
            if(l1->val > l2->val) {
                cur->next = l2;
                l2 = l2->next;
            } else {
                cur->next = l1;
                l1 = l1->next;
            }
            cur = cur->next;
        }
        
        cur->next = l1 ? l1 : l2;
        
        cur = dummyHead->next;
        delete(dummyHead);
        return cur;
    }
};

3.分治优化

我们使用暴力法进行遍历，时间复杂度会比较高，这里使用分治方法优化时间复杂度。核心还是合并两个有序链表。

C++ 代码如下：

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* mergeKLists(vector<ListNode*>& lists) {
        //因为上一道题做过了合并两个升序链表
        //这道题我们可以初始化一个答案链表，然后将原始数组中每个链表与其进行合并
        //可以使用分治合并进行时间复杂度优化

        //分治法
        return merge(lists, 0, lists.size() - 1);
    }

    ListNode* merge(vector<ListNode*>& lists, int l, int r) {
        if(l == r) return lists[l];
        if(l > r) return nullptr;
        int mid = l + (r - l) / 2;
        return mergeTwoList(merge(lists, l, mid), merge(lists, mid + 1, r));
    }

    ListNode* mergeTwoList(ListNode *l1, ListNode *l2) {
        //合并两个升序链表
        ListNode *dummyHead = new ListNode(0, nullptr);
        ListNode *cur = dummyHead;
        while(l1 && l2) {
            if(l1->val > l2->val) {
                cur->next = l2;
                l2 = l2->next;
            } else {
                cur->next = l1;
                l1 = l1->next;
            }
            cur = cur->next;
        }
        
        cur->next = l1 ? l1 : l2;
        
        cur = dummyHead->next;
        delete(dummyHead);
        return cur;
    }
};