第10周算法思想-排序

最新推荐文章于 2024-05-03 23:29:24 发布

原创最新推荐文章于 2024-05-03 23:29:24 发布 · 148 阅读

0 ·

CC 4.0 BY-SA版权

leetcode weekly 专栏收录该内容

20 篇文章

订阅专栏

本文详细介绍了四种不同的排序算法实现：堆排序中寻找第K个最大元素、基于频率的元素排序、字符串字符频率排序以及数组颜色排序。通过实例展示了不同排序算法的时间复杂度和空间复杂度，包括直接排序、堆排序、快速排序的partition思想以及计数排序。这些方法在解决实际问题中具有广泛的应用。

文章目录

最大的第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;
            }
        }
    }
};