第10周 算法思想-排序

• 最大的第K个 215. Kth Largest Element in an Array(Medium)
• 出现频率最多的 k 个元素 347. Top K Frequent Elements(Medium)
• 按照字符出现次数对字符串排序 451. Sort Characters By Frequency(Medium)
• 按颜色进行排序 75. Sort Colors (Medium)

堆

最大的第K个

class Solution {
public:
    int findKthLargest_sort(vector<int>& nums, int k) {
        /*
        思路：直接排序
        时间复杂度：O(nlogn)
        空间复杂度：O(1)
        */
        sort(nums.begin(), nums.end());
        return nums[nums.size() - k];
    }
    int findKthLargest_heap(vector<int>& nums, int k) {
        /*
        思路：堆
        时间复杂度：O(klogn)
        空间复杂度：O(1)
        */
        priority_queue<int> pq(nums.begin(), nums.end());   // 默认是最大堆
        
        while(k > 1){
            pq.pop();
            k -= 1;
        }
        
        return pq.top();
    }
    int findKthLargest(vector<int>& nums, int k) {
        /*
        思路：使用快速排序中用到的partion的思想，随机选值对数组进行划分，直到找到第k大的数
        时间复杂度：O(n)
        空间复杂度：O(1)
        */
        k = nums.size() - k;   // 第k大的数的index
        int left = 0, right = nums.size() - 1;
        while(left < right){
            int splited_idx = partion(nums, left, right);
            if(splited_idx == k)
                break;
            else if(splited_idx > k)
                right = splited_idx - 1;
            else if(splited_idx < k)
                left = splited_idx + 1;
        }
        return nums[k];
    }
    int partion(vector<int>& nums, int left, int right){
        int i = left+1, j = right;
        while(1){
            while(i < right && nums[i] <= nums[left])
                i += 1;
            while(j > left && nums[j] > nums[left])
                j -= 1;
            if(i >= j)
                break;            
            swap(nums[i], nums[j]);

        }
        swap(nums[left], nums[j]);
        return j;
    }
};

桶排序

出现频率最多的 k 个元素

typedef pair<int,int> P;
bool cmp(P& a, P& b){
    return a.second < b.second;
}

class Solution {
public:
    vector<int> topKFrequent(vector<int>& nums, int k) {
        /*
        思路：先用map进行计数，然后返回频率最高的top k
        时间复杂度：O(nlogn)
        空间复杂度：O(n)
        */
        map<int,int> mp;
        vector<int> ans;
        
        for(int num: nums)
            mp[num] += 1;
        
        vector<P> counter;
        
        for(auto k: mp)
            counter.push_back(make_pair(k.first, k.second));
        
        sort(counter.begin(), counter.end(), cmp);
        
        int n = counter.size();
        for(int i = n-1; i >= n-k; i--)
            ans.push_back(counter[i].first);
        
        return ans;
    }
};

按照字符出现次数对字符串排序

typedef pair<char,int> P;
bool cmp(P& a, P& b){
    return a.second > b.second;
}

class Solution {
public:
    string frequencySort(string s) {
        /*
        思路：先map计数，然后构造pair排序
        时间复杂度：O(nlogn)
        空间复杂度：O(n)
        */
        map<char, int> mp;
        for(int i = 0;i < s.size(); i++)
            mp[s[i]] += 1;
        
        vector<P> counter;
        
        for(auto item: mp)
            counter.push_back(item);
        
        sort(counter.begin(), counter.end(), cmp);
        
        string ans(s.size(), 'a');
        int index = 0;
        
        for(int i = 0;i <counter.size(); i++){
            for(int j = 0;j < counter[i].second; j++)
                ans[index++] = counter[i].first;
        }
        
        return ans;
    }
};

按颜色进行排序

class Solution {
public:
    void sortColors(vector<int>& nums) {
        /*
        思路：用index0和index2分别表示下一个0，2该放的位置，从头开始遍历，遍历过程中发现0则放到index0处，发现2则放到2处，发现1则不用管，直接遍历下一个
        时间复杂度：O(n)
        空间复杂度：O(1)
        */
        int index0 = 0, curr = 0, index2 = nums.size() - 1;
        while(curr <= index2){
            if(nums[curr] == 0){
                swap(nums[index0], nums[curr]);
                index0 += 1;
                curr += 1;
            }
            else if(nums[curr] == 1)
                curr += 1;
            else{
                swap(nums[curr], nums[index2]);
                index2 -= 1;
            }
        }
    }
};