LeetCode 面试题 17.14 最小K个数[排序最小堆快排] HERODING的LeetCode之路

最新推荐文章于 2024-10-20 21:47:19 发布

HERODING77

最新推荐文章于 2024-10-20 21:47:19 发布

阅读量107

点赞数 1

分类专栏： LeetCode 文章标签： leetcode 算法 c++ 数据结构程序设计

本文链接：https://blog.csdn.net/HERODING23/article/details/120073452

版权

LeetCode 专栏收录该内容

733 篇文章 6 订阅

订阅专栏

这篇博客探讨了三种不同的方法来解决找到数组中最小的K个数的问题：直接排序、使用最小堆和快速选择。每种方法的时间复杂度和空间复杂度都有所不同，适用于不同的场景。排序算法在信息技术领域中是基础且重要的，而最小堆和快速选择提供了更高效的解决方案，特别是在大数据集上。

摘要由CSDN通过智能技术生成

在这里插入图片描述
解题思路：
一道平平无奇的题目，关键在于方法的使用，这道题只要排序完成，就可以得出答案，首先的方法是调用sort函数排序，时间复杂度为O(nlogn)，空间复杂度为O(logn)，代码如下：

class Solution {
public:
    vector<int> smallestK(vector<int>& arr, int k) {
        sort(arr.begin(), arr.end());
        return vector<int>(arr.begin(), arr.begin() + k);
    }
};

第二个方法是最小堆，定义好最小堆的大小为k，然后往里面填充，当个数大于k时进行比较，把大的剔除掉，时间复杂度为O(nlogk)，空间复杂度为O(k)，代码如下：

class Solution {
public:
    vector<int> smallestK(vector<int>& arr, int k) {
        vector<int> vec(k, 0);
        if (k == 0) { // 排除 0 的情况
            return vec;
        }
        priority_queue<int> Q;
        for (int i = 0; i < k; ++i) {
            Q.push(arr[i]);
        }
        for (int i = k; i < (int)arr.size(); ++i) {
            if (Q.top() > arr[i]) {
                Q.pop();
                Q.push(arr[i]);
            }
        }
        for (int i = 0; i < k; ++i) {
            vec[i] = Q.top();
            Q.pop();
        }
        return vec;
    }
};

最后一种方法是快排，快排也是经典的排序方法了，实现起来比较复杂，时间复杂度可以到O(nlogn)，空间复杂度为O(1)，代码如下：

class Solution {
    int partition(vector<int>& nums, int l, int r) {
        int pivot = nums[r];
        int i = l - 1;
        for (int j = l; j <= r - 1; ++j) {
            if (nums[j] <= pivot) {
                i = i + 1;
                swap(nums[i], nums[j]);
            }
        }
        swap(nums[i + 1], nums[r]);
        return i + 1;
    }

    // 基于随机的划分
    int randomized_partition(vector<int>& nums, int l, int r) {
        int i = rand() % (r - l + 1) + l;
        swap(nums[r], nums[i]);
        return partition(nums, l, r);
    }

    void randomized_selected(vector<int>& arr, int l, int r, int k) {
        if (l >= r) {
            return;
        }
        int pos = randomized_partition(arr, l, r);
        int num = pos - l + 1;
        if (k == num) {
            return;
        } else if (k < num) {
            randomized_selected(arr, l, pos - 1, k);
        } else {
            randomized_selected(arr, pos + 1, r, k - num);
        }
    }

public:
    vector<int> smallestK(vector<int>& arr, int k) {
        srand((unsigned)time(NULL));
        randomized_selected(arr, 0, (int)arr.size() - 1, k);
        vector<int> vec;
        for (int i = 0; i < k; ++i) {
            vec.push_back(arr[i]);
        }
        return vec;
    }
};