[学习报告]《LeetCode零基础指南》(第五讲) 排序

YUAN_798 2022-01-16 21:43:23

一、今日知识点总结

1. 学习了如何使用c语言重写cmp函数以实现自己需要的排序方式

2. 学习了贪心和排序相关的算法题

二、今日做题记录

法一：

class Solution {
public:
    vector<int> sortArray(vector<int>& nums) {
        sort(nums.begin(),nums.end());
        return nums;
    }
};

法二：

 
int cmp(const void *a,const void *b){
    return *(int*)a - *(int*)b;
}

int* sortArray(int* nums, int numsSize, int* returnSize){
    qsort(nums,numsSize,sizeof(int),cmp);
    *returnSize = numsSize;
    return nums;
}

169. 多数元素

法一：c++ 摩尔投票法

class Solution {
public:
    int majorityElement(vector<int>& nums) {
        //计数器
        int count = 0;
        //众数值
        int x = -1;

        for(int i = 0; i < nums.size(); i++){
            //如果count==0，说明当前没有数字是众数
            if(count == 0){
                x = nums[i];
                count++;
            }else if(nums[i] == x){
            //如果当前数字等于众数，则计数器加1
                count++;
            }else{
            //遇到一个非众数，计数器减1
                count--;
            }
        }
        return x;
    }
};

法二：排序后取中间位置的数字必定为众数

//升序排序
int cmp(const void* a,const void* b){
    return *(int*)a - *(int*)b;
}


int majorityElement(int* nums, int numsSize){
    qsort(nums,numsSize,sizeof(int),cmp);
    return nums[numsSize / 2];
}

217. 存在重复元素

将数组升序排序，如果存在重复元素，必定存在两个相等的相邻元素

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

164. 最大间距

排序后，遍历元素取元素间的最大值

class Solution {
public:
    int maximumGap(vector<int>& nums) {
        int numsSize = nums.size();
        if(numsSize < 2){
            return 0;
        }else{
            sort(nums.begin(),nums.end());
            int maxDistance = 0;
            for(int i = 1; i < numsSize; i++){
                int distance = nums[i] - nums[i - 1];
                maxDistance = distance > maxDistance ? distance:maxDistance;
            }
            return maxDistance;
        }

    }
};

905. 按奇偶排序数组

方法一：类似于快排的一次划分，从前往后扫描偶数，从后往前扫描奇数，最后将不符合条件的奇偶数互换。

class Solution {
public:
    vector<int> sortArrayByParity(vector<int>& nums) {
        int low = 0;
        int high = nums.size() - 1;
        while(low < high){
            //从前往后扫描偶数
            while((low < high) && ((nums[low]&1) == 0)) low++;
            //从后往前扫描奇数
            while((low < high) && ((nums[high]&1) == 1)) high--;
            if(low < high){
                swap(nums[low],nums[high]);
            } 
            low++;
            high--;
        }
        return nums;

    }
};

方法二：实现c语言的cmp函数，并申请一个辅助数组，将元素按照要求复制到新数组中。


int Qua(int x) {
    return x & 1;
}

int cmp(const void *a, const void *b) {
    return Qua(*(int *)a) - Qua(*(int *)b);
}

int* sortArrayByParity(int* nums, int numsSize, int* returnSize){
    int i;
    int *ret = (int *)malloc( sizeof(int) * numsSize ); 
    for(i = 0; i < numsSize; ++i) {
        ret[i] = nums[i];                              
    }
    qsort(ret, numsSize, sizeof(int), cmp);              
    *returnSize = numsSize;                             
    return ret;
}

539. 最小时间差

将时间转化为分钟，并存入一位数组，然后将一维数组中的元素排序，遍历求出相邻元素的最小值，需要特殊处理一下跨天的情况。

class Solution {
public:
    int findMinDifference(vector<string>& timePoints) {
        int n = timePoints.size();
        int times[n];
        //将时间转换为分钟，并存入一维数组times中
        for(int i = 0; i < n; i++){
            times[i] = ((timePoints[i][0] - '0') * 10 + (timePoints[i][1] -'0')) * 60 
            +(timePoints[i][3] - '0') * 10 + (timePoints[i][4] - '0');
        }
        //升序排序
        sort(times,times + n);

        int res = INT_MAX;
        for(int i = 1;i < n; i++){
            res = min(res,times[i] - times[i-1]);
        }
        res = min(res, 24*60+times[0] - times[n-1]);
        
        return res;
        
    }
};

976. 三角形的最大周长

排序加贪心，先递增排序，然后倒序枚举

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

881. 救生艇

排序加贪心，先递增排序，然后双指针遍历，如果最胖的和最瘦的体重之和没超重则两个人一艘船，否则则最胖的一个人一艘。

class Solution {
public:
    int numRescueBoats(vector<int>& people, int limit) {
        //指向最瘦的人的指针
        int light = 0;
        //指向最胖的人的指针
        int heavy = people.size() - 1;
        //船数
        int sum = 0;
        sort(people.begin(),people.end());
        
        while(light <= heavy){
            if(people[light] + people[heavy] <= limit){
                light++;
                heavy--;
            }else{
                heavy--;
            }
            sum++;
        }
        return sum;
    }
};