LeetCode 排序题库

wanger_xx

已于 2022-02-11 11:50:36 修改

阅读量395

点赞数

分类专栏： leetcode刷题手记文章标签： leetcode 排序算法

于 2022-02-10 11:36:29 首次发布

本文链接：https://blog.youkuaiyun.com/qq_52138199/article/details/122856035

版权

leetcode刷题手记专栏收录该内容

18 篇文章

订阅专栏

本文探讨了几种与排序和会议室管理相关的LeetCode问题，包括判断会议能否安排、最小会议室需求以及不同场景下的排序策略。通过排序优化，实现了有效解决这些问题的算法，并给出了详细的代码实现，涉及到了二分查找、贪心策略和三向切分等技术。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

排序题单

困了累了做排序。

lc.252 会议室

class Solution {
public:
    bool canAttendMeetings(vector<vector<int>>& intervals) {
        sort(intervals.begin() , intervals.end()) ;
        for(int i = 1 ; i < intervals.size() ; i ++){
            if(intervals[i][0] < intervals[i - 1][1]) return false; 
        }
        return true ;
    }
};

lc.253 会议室 II

有空闲的房间就进，没有就新开一个房间

class Solution {
public:
    int minMeetingRooms(vector<vector<int>>& intervals) {
        vector<int> EndTime ;
        int ans ;
        sort(intervals.begin() , intervals.end()) ;
        EndTime.emplace_back(intervals[0][1]) ;
        for(int i = 1 ; i < intervals.size() ; i ++){
            int flag = 0 ;
            for(int j = 0 ; j < EndTime.size() ; j ++){
                if(intervals[i][0] < EndTime[j]){
                    flag ++ ;
                }
                else{
                    EndTime[j] = intervals[i][1] ;
                    break ;
                }
            }
            if(flag == EndTime.size()) EndTime.emplace_back(intervals[i][1]) ;
        }
        return (int)EndTime.size() ;
    }
};

lc.259 较小的三数之和

class Solution {
public:
    int threeSumSmaller(vector<int>& nums, int target) {
        int ans = 0 ;
        if(nums.size() < 3) return 0 ;
        sort(nums.begin() , nums.end()) ;
        for(int i = nums.size() - 1 ; i >= 0 ; i --){
            int sum = target - nums[i] ;
            int l = 0 , r = i - 1 ;
            while(l < r){
                int presum = nums[l] + nums[r] ;
                if(presum >= sum) r -- ;
                else {
                    ans += r - l ;
                    l ++ ;
                }
            }
        }
        return ans ;
    }
};

sort结束后从后遍历，如果k的值小于target，将剩余的值在 0 ~ k-1 中查找答案。注意到一旦反向找到结果加上的是剩余范围的所有值ans += r - l ;。

lc.280 摆动序列

class Solution {
public:
    void wiggleSort(vector<int>& nums) {
        sort(nums.begin() , nums.end());
        for(int i = 1 ; i < nums.size() - 1 ; i += 2){
            swap(nums[i] , nums[i + 1]) ;
        }
        return ;
    }
};

sort 结束从第二个位置开始两两互换。

贪心

class Solution {
public:
    void wiggleSort(vector<int>& nums) {
        for (int i = 0; i < nums.size() - 1 ; i ++) {
            if (((i % 2 == 0) && nums[i] > nums[i + 1]) || ((i % 2 == 1) && nums[i] < nums[i + 1])) {
                swap(nums[i], nums[i + 1]);
            }
        }
        return ;
    }
};

每次只考虑当前位置和下一位置，如果满足条件不动，不满足就交换一次。

lc.324 摆动序列 II

这题就不能用 lc.280 的两种方法来实现了。

class Solution {
public:
    void wiggleSort(vector<int>& nums) {
        auto midptr = nums.begin() + nums.size() / 2;
        nth_element(nums.begin(), midptr, nums.end());
        int mid = *midptr;
        
        // 3-way-partition
        int i = 0, j = 0, k = nums.size() - 1;
        while(j < k){
            if(nums[j] > mid){
                swap(nums[j], nums[k]);
                --k;
            }
            else if(nums[j] < mid){
                swap(nums[j], nums[i]);
                ++i;
                ++j;
            }
            else{
                ++j;
            }
        }
        
        if(nums.size() % 2) ++midptr;
        vector<int> tmp1(nums.begin(), midptr);
        vector<int> tmp2(midptr, nums.end());
        for(int i = 0; i < tmp1.size(); ++i){
            nums[2 * i] = tmp1[tmp1.size() - 1 - i];
        }
        for(int i = 0; i < tmp2.size(); ++i){
            nums[2 * i + 1] = tmp2[tmp2.size() - 1 - i];
        }
    }
};