TopK问题

1. 无序数组找最大的K个数

方法1: 排序＋查找 时间复杂度O(NlogN)

int findKthLargest(vector<int> & nums, int k) {    sort(nums.begin(), nums.end());    return nums[k-1];}

方法2: 类似快排的分治思想 O(N)

int partition(vector<int> &nums, int left, int right) {    int l = left, r = right;    int pivot = nums[l];    while (l < r) {        while (l < r && nums[r] <= pivot)            r--;        nums[l] = nums[l];        while (l < r && nums[l] >= pivot)            l++;        nums[r] = nums[l];    }    nums[l] = pivot;    return l; }int findKthLargest_QuickSort(vector<int> nums, int k) {    int left = 0, right = nums.size() - 1;    while (true) {        int pos = partition(nums, left, right);        if (pos == k - 1) return nums[pos];        if (pos > k - 1) right = pos;        else left = pos;    }}

方法3：堆排序思想，调整堆k次

void max_heapify(vector<int> &nums, int p, int heap_size) {    int child = 2 * p + 1;    int p_val = nums[p];    while (child < heap_size) {        if (child + 1 < heap_size && nums[child] < nums[child+1]) {            child += 1;        }        if (nums[child] > p_val) {            nums[p] = nums[child] ;            p = child;            child = 2 * p + 1;        } else             break;    }    nums[p] = p_val;}void build_max_heap(vector<int> &nums, int heap_size) {    int heap_size = nums.size();    for (int i = (heap_size >> 1) -1; i >= 0; i--) {        max_heapify(nums, i, heap_size);    }}int findKthLargest_Heap(vector<int> nums, int k) {    build_max_heap(nums, heap_size);    for (int i = 0; i < k; i++) {        swap(nums[0], nums[heap_size-1]);        heap_size --;        max_heapify(nums, 0);    }    return nums[heap_size];}

方法4: 利用STL的priority_queue

int findKthLargest(vector<int>& nums, int k) {        priority_queue<int> pq(nums.begin(), nums.end());        for (int i = 0; i < k - 1; i++) {            pq.pop();        }        return pq.top();    }

2. 无序数组找K最频繁（要求时间复杂度小于O(NlogN)）

因为k最大可以等于n，所以在最坏情况下需要统计所有数字的出现次数。那么这个问题就分成了两个部分：

1. 统计所有不同的数字出现的次数
2. 找出出现次数前k大的数字

因为最后只需要返回k个数字，所以可以维护一个大小为k的小根堆。当新的数字出现的次数大于堆中最小的次数时，对堆进行更新。时间复杂度是O(n log k)。

// hash + priority_queuevector<int> topKFrequent(vector<int>& nums, int k) {        unordered_map<int,int> map;        for(int num : nums){            map[num]++;        }                vector<int> res;        // pair<first, second>: first is frequency,  second is number        priority_queue<pair<int,int>> pq;         for(auto it = map.begin(); it != map.end(); it++){            pq.push(make_pair(it->second, it->first));            if(pq.size() > (int)map.size() - k){                res.push_back(pq.top().second);                pq.pop();            }        }        return res;    }

可以采用桶排序做进一步优化，该算法复杂度只和需要排序的数字的大小有关。可以用一个数组bucket记录每个数字出现的次数，每次把数字丢到相应编号的桶中，然后从后往前穷举每一个桶，取出其中的元素直到取满k个。时间复杂度是O(n)。

vector<int> topKFrequent(vector<int>& nums, int k) {        vector<int> res;        if (!nums.size()) return res;        unordered_map<int, int> cnt;        for (auto num : nums) cnt[num]++;        vector<vector<int>> bucket(nums.size() + 1);        for (auto kv : cnt) {            bucket[kv.second].push_back(kv.first);        }        for (int i = bucket.size() - 1; i >= 0; --i) {            for (int j = 0; j < bucket[i].size(); ++j){                res.push_back(bucket[i][j]);                if (res.size() == k) return res;            }        }        return res;    }