《五月集训》（第二十九天）——分而治之

前言

        欢迎大家积极在评论区留言发表自己的看法，知无不言，言无不尽，养成每天刷题的习惯，也可以自己发布优质的解题报告，供社区一同鉴赏，吸引一波自己的核心粉丝。
        今天是五月集训第二十九天：分而治之🔥🔥🔥🔥🔥

一、练习题目

        21. 合并两个有序链表
        1985. 找出数组中的第 K 大整数
        558. 四叉树交集
        932. 漂亮数组

二、算法思路

• 1、21. 合并两个有序链表：利用递归实现
• 2、1985. 找出数组中的第 K 大整数：第一个尝试了重载sort函数；第二个呢就是用归并排序。
• 3、558. 四叉树交集：这一题还没看完下午开完会抽时间补一下
• 4、932. 漂亮数组：😢

三、源码剖析

// 21. 合并两个有序链表
class Solution {
public:
    ListNode* mergeTwoLists(ListNode* list1, ListNode* list2) {
        if(list1 == nullptr) {
            return list2;
        } else if(list2 == nullptr) {
            return list1;
        } //(1)
        ListNode* t = new ListNode();
        if(list1->val < list2->val) {
            t->val = list1->val;
            t->next = mergeTwoLists(list1->next, list2);
        } else {
            t->val = list2->val;
            t->next = mergeTwoLists(list1, list2->next);
        } //(3)
        return t;
    }
};

• 1、递归实现；
• 2、分别考虑两个链表为空的情况；
• 3、这里是不为空的情况，val取小的那个值，next利用递归继续计算。

// 1985. 找出数组中的第 K 大整数
// 方法一
class Solution {
public:
    string kthLargestNumber(vector<string>& nums, int k) {
        sort(nums.begin(), nums.end(), [&](const string &a, const string &b){
            if(a.size() != b.size()) {
                return a.size() > b.size();
            }
            return a > b;
        });
        return nums[k - 1];
    }
};

//方法二
class Solution {
public:
    bool isBiggerThan(const string &a, const string &b) {
        if(a.size() != b.size()) {
            return a.size() > b.size();
        }
        return a > b;
    }
    void mergesort(vector<string>& nums, int l, int r) {
        if(l >= r) {
            return ;
        }
        int mid = (l + r) >> 1;
        mergesort(nums, l, mid);
        mergesort(nums, mid+1, r);
        vector<string> tmp;
        int lidx = l, ridx = mid + 1;
        while (lidx <= mid || ridx <= r) {
            if(lidx == mid + 1) {
                tmp.emplace_back(nums[ridx++]);
            } else if(ridx == r + 1) {
                tmp.emplace_back(nums[lidx++]);
            } else {
                if(isBiggerThan(nums[lidx], nums[ridx])) {
                    tmp.emplace_back(nums[lidx++]);
                } else {
                    tmp.emplace_back(nums[ridx++]);
                }
            }
        }
        for(int i = l; i <= r; ++i) {
            nums[i] = tmp[i - l];
        }
    }

    string kthLargestNumber(vector<string>& nums, int k) {
        int n = nums.size() - 1;
        mergesort(nums, 0, n);
        return nums[k - 1];
    }
};

• 1、方法一就是重载一下sort，这个优化做的很好自己写的方法二没有这快。
• 2、方法二用的归并排序。

// 558. 四叉树交集

• 1、

// 932. 漂亮数组

• 1、