最小的k个数

力扣地址

小顶堆：

时间复杂度：

空间复杂度：

利用的就是堆排序的性质，只给k个数排序

class Solution {
public:
    void MinHeapSort(vector<int>& arr, int index, int end) {
        int parent = index;
        int child = (parent << 1) + 1;
        while (child <= end) {
            if (child < end && arr[child + 1] < arr[child]) ++child;
            if (arr[child] > arr[parent]) return;
            std::swap(arr[child], arr[parent]);
            parent = child;
            child = (parent << 1) + 1;
        }
    }

    void HeadSort(vector<int>& arr, int k, int len) {
        for (int i = (len >> 1); i >=0; --i) {
            MinHeapSort(arr, i, len - 1);
        }

        for (int i = len - 1; i >= len - k; --i) {
            std::swap(arr[0], arr[i]);
            MinHeapSort(arr, 0, i - 1);
        }
    }

    vector<int> getLeastNumbers(vector<int>& arr, int k) {
        int len = arr.size();
        if (len <= k) return arr;
        HeadSort(arr, k, len);
        return {arr.rbegin(), arr.rbegin() + k};
    }
};

快速选择：

时间复杂度：理想状态，最坏状态

空间复杂度：理想状态，最坏状态

快排思想，利用partition 获取 pivot ，pivot的左边小于等于arr[pivot]，pivot右边大于等于arr[pivot]，而最小的k个数就是左边都比第k小的数小或者相等

class Solution {
public:
    int partition(vector<int>& arr, int low, int high) {
        int pivot = arr[low];
        while (low < high) {
            while (low < high && arr[high] >= pivot) --high;
            arr[low] = arr[high];
            while (low < high && arr[low] <= pivot) ++low;
            arr[high] = arr[low];
        }
        arr[low] = pivot;
        return low;
    }

    void QuickSelect(vector<int>& arr, int low, int high, int k) {
        if (low >= high) return;
        int pivot = partition(arr, low, high);
        if (k == pivot) {
            return;
        }
        else if (k < pivot) {
            QuickSelect(arr, low, pivot - 1, k);
        }
        else {
            QuickSelect(arr, pivot + 1, high, k);
        }
    }

    vector<int> getLeastNumbers(vector<int>& arr, int k) {
        int len = arr.size();
        if (len <= k) return arr;
        QuickSelect(arr, 0, len - 1, k - 1);
        return {arr.begin(), arr.begin() + k};
    }
};