堆排序 VS 快速排序 解决 TOP K 问题

解决 TOP k 问题通常可采用 堆排序 和 快速排序的思想

1.  大根堆(前 K 小) / 小根堆（前 K 大):   时间复杂度O(NlogK) 

c++ STL 中提供了  priority_queue 实现堆的基本功能，比如 priority_queue <int> pq;

堆 pq 的元素都是 int 型的，priority_queue 默认使用 vector 作为 堆的底层实现，pq默认是个

大根对，priority_queue <int> pq 等同于 priority_queue <int，vector<int>,less<int> > pq;

小根堆 ：priority_queue <int，vector<int>,greater<int> > pq1,

堆中的元素必须 是可以比较大小的。

Tips : c++  std :: pair<K,V>，是可以比较大小的。比较的逻辑如下：

template<class _Ty1, class _Ty2>
 inline  bool operator<(const pair<_Ty1, _Ty2>& _Left, 
                                  const pair<_Ty1, _Ty2>& _Right)
    {    // test if _Left < _Right for pairs
    return (_Left.first < _Right.first ||
        !(_Right.first < _Left.first) && _Left.second < _Right.second);
    }

2 、用快排变形高效解决 TopK 问题：时间复杂度O(N)

注意找前 K 大/前 K 小问题不需要对整个数组进行 O(NlogN)O(NlogN) 的排序！

比如找到数组 arr 中的前 k 小个元素，使用快速排序的划分操作 一次可以确定数组中一个元素的最终位置。不断缩小划分的范围，

最终的目标是确定位置  k - 1 上的最终元素。

根据快速排序思想，要是数组的 k -1 位置上的元素确定了，则 [0:k-1] 就是所求的 前 K 小个元素。

求 前 K 大个元素 需使用划分法 确定 n - k 位置上的元素，[n-k,k-1] 就是所求的 前 k 大个元素。

 

3. 示例

 

 方法一.  快速排序解决 TOP K 问题

class Solution {
public:
    vector<vector<int>> kClosest(vector<vector<int>>& points, int k)
    {
        const int n = points.size();
        vector<int> index_vec(n);
        for(int i = 0 ; i < n ; ++i)
        {
            index_vec[i] = i;
        }
        int left = 0, right = n - 1;
        bool flag = false;
        while(left <= right)
        {
            int t = partition(points,index_vec,left,right);
            if(t == -1) break;
            if(t == k - 1)
            {
                flag = true;
                break;
            }
            else if( t > k - 1)
            {
                right = t - 1;
            }
            else
            {
                left = t + 1;
            }
        }
        vector<vector<int>> res;
        if(flag)
        {
            for(int i = 0;i < k; ++i)
            {
                res.push_back(points[index_vec[i]]);
            }
        }
        return res;
    }
    
    int partition(vector<vector<int>>& points,vector<int> &index_vec,int l,int r)
    {
        if(l > r)
        {
            return -1;
        }
        int i = l,j = r;
        int pivot = cal_dist(points[index_vec[l]]);
        while( true )
        {
            while(i <= j && cal_dist(points[index_vec[i]]) <= pivot) ++i;
            while(i <= j && cal_dist(points[index_vec[j]]) >= pivot) --j;
            if(i > j)
            {
                break;
            }
            std::swap(index_vec[i],index_vec[j]);
        }
        std::swap(index_vec[l],index_vec[j]);//最后一次交换 index_vec[l] 最终的位置确定
        return j;
    }
    
    inline int cal_dist(vector<int>& point)
    {
        return point[0] * point[0] + point[1] * point[1];
    }
};

方法二.  大根堆解决 TOP K 问题

//Top K we
  class my_less {
    public:
        bool operator()(const pair<int, int>& pr1, const pair<int, int>& pr2) {
            return pr1.first < pr2.first;
        }
    };

class Solution {
public:
    vector<vector<int>> kClosest(vector<vector<int>>& points, int K)
    {
        //priority_queue<pair<int, int>,vector<pair<int, int>>,my_less> q;//大顶堆
        priority_queue<pair<int, int>> q;
        const int n = points.size();
        for (int i = 0; i < n; ++i)
        {
            int dist = points[i][0] * points[i][0] + points[i][1] * points[i][1];
            if(q.size() < K)
            {
               q.push(make_pair(dist,i));
                continue;
            }
            if (dist < q.top().first)
            {
                q.pop();
                q.emplace(dist, i);
            }
        }
        vector<vector<int>> ans;
        while (!q.empty())
        {
            ans.push_back(points[q.top().second]);
            q.pop();
        }
        return ans;
    }
};