LeetCode—排序

LeetCode—排序

快速选择
用于求解 Kth Element 问题，也就是第 K 个元素的问题。

可以使用快速排序的 partition() 进行实现。需要先打乱数组，否则最坏情况下时间复杂度为 O(N2)。

堆
用于求解 TopK Elements 问题，也就是 K 个最小元素的问题。可以维护一个大小为 K 的最小堆，最小堆中的元素就是最小元素。最小堆需要使用大顶堆来实现，大顶堆表示堆顶元素是堆中最大元素。这是因为我们要得到 k 个最小的元素，因此当遍历到一个新的元素时，需要知道这个新元素是否比堆中最大的元素更小，更小的话就把堆中最大元素去除，并将新元素添加到堆中。所以我们需要很容易得到最大元素并移除最大元素，大顶堆就能很好满足这个要求。

堆也可以用于求解 Kth Element 问题，得到了大小为 k 的最小堆之后，因为使用了大顶堆来实现，因此堆顶元素就是第 k 大的元素。

快速选择也可以求解 TopK Elements 问题，因为找到 Kth Element 之后，再遍历一次数组，所有小于等于 Kth Element 的元素都是 TopK Elements。

可以看到，快速选择和堆排序都可以求解 Kth Element 和 TopK Elements 问题。

1、Kth Element
T.215 Kth Largest Element in an Array (Medium)

class Solution {
public:
    int findKthLargest(vector<int>& nums, int k) {
        int left=0;
        int 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-1;
            else left=pos+1;

        }

    }
    int partition(vector<int>& nums, int left, int right){
        int pivot = nums[left];
        int l=left+1;
        int r=right;
        while(l<=r){
            if(nums[l]<pivot && nums[r]>pivot){
                swap(nums[l++], nums[r--]);
            }
            if(nums[l]>=pivot)
            ++l;
            if(nums[r]<=pivot)
            --r;
        }
        swap(nums[left], nums[r]);
        return r;
    }
};

桶排序
1、出现频率最多的 k 个元素
T347 Top K Frequent Elements (Medium)

class Solution {
public:
    vector<int> topKFrequent(vector<int>& nums, int k) {
        unordered_map<int, int> m;
        vector<vector<int>> bucket(nums.size()+1);
        vector<int> res;
        for(auto a : nums) ++m[a];
        for(auto it : m)
        bucket[it.second].push_back(it.first);
        for(int i = nums.size(); 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;

    }
};

class Solution {
public:
    vector<int> topKFrequent(vector<int>& nums, int k) {
        unordered_map<int, int> m;
        priority_queue<pair<int, int>> q;
        vector<int> res;
        for (auto a : nums) ++m[a];
        for (auto it : m) q.push({it.second, it.first});
        for (int i = 0; i < k; ++i) {
            res.push_back(q.top().second); q.pop();
        }
        return res;
    }
};

2、按照字符出现次数对字符串排序
T451 Sort Characters By Frequency (Medium)

class Solution {
public:
    string frequencySort(string s) {
        string res="";
        priority_queue<pair<int, char>> q;
        unordered_map<char, int> m;
        for(char c : s) ++m[c];
        for(auto a : m)
        q.push({a.second, a.first});
        while(!q.empty()){
            auto t = q.top();
            q.pop();
            res.append(t.first, t.second);
        }
        return res;



    }
};

荷兰国旗问题
荷兰国旗包含三种颜色：红、白、蓝。

有三种颜色的球，算法的目标是将这三种球按颜色顺序正确地排列。它其实是三向切分快速排序的一种变种，在三向切分快速排序中，每次切分都将数组分成三个区间：小于切分元素、等于切分元素、大于切分元素，而该算法是将数组分成三个区间：等于红色、等于白色、等于蓝色。

1、按颜色进行排序
T.75 Sort Colors (Medium)

class Solution {
public:
    void sortColors(vector<int>& nums) {
        vector<int> colours(3);
        for(int num : nums)  ++colours[num];
        for(int i=0,cur=0; i<3; ++i){
            for(int j=0; j<colours[i]; ++j){
                nums[cur++] = i;
            }
        }
        
    }
};

class Solution {
public:
    void sortColors(vector<int>& nums) {
        int left = 0, right = (int)nums.size() - 1, cur = 0;
        while (cur <= right) {
            if (nums[cur] == 0) {
                swap(nums[cur++], nums[left++]);
            } else if (nums[cur] == 2) {
                swap(nums[cur], nums[right--]);
            } else {
                ++cur;
            }
        }
    }
};