C语言学习--练习2（排序）

西柚小萌新

已于 2024-03-09 19:10:07 修改

阅读量322

点赞数 3

分类专栏： C语言入门到深入 C语言练习（PTA+LeetCode）文章标签： c语言数据结构排序算法

于 2024-03-07 19:03:24 首次发布

本文链接：https://blog.csdn.net/qq_58602552/article/details/136541864

版权

C语言入门到深入同时被 2 个专栏收录

23 篇文章 2 订阅

订阅专栏

C语言练习（PTA+LeetCode）

15 篇文章 0 订阅

订阅专栏

1.排序数组

/**
 * Note: The returned array must be malloced, assume caller calls free().
 */
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);//对数组a进行排序
    * returnSize=numsSize;
    return nums;
}
//使用C语言内置的快速排序函数qsort()

详情请看：C语言学习--快速排序函数sqort()-CSDN博客

2.多数元素

方法一：排序计数法：

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);//对数组a进行排序
    int ans=0;//用于计数，记录每个元素出现的次数
    int max=0;//用于记录最大次数
    int maxval=nums[0];//用于记录最大次数所对应的元素
    for(int i=1;i<numsSize;i++){
        if(nums[i]==nums[i-1]){//前后相等的话
            ans++;
            if(ans>max){
                max=ans;
                maxval=nums[i];
            }//前后不相等则重新计数
        }else{
            ans=1;

        }
    }//of for
    return maxval;
}

其实有更简单的方法:摩尔投票算法：C语言学习--摩尔投票算法-CSDN博客

int majorityElement(int* nums, int numsSize) {
int note=nums[0];
int count=1;
for(int i=1;i<numsSize;i++){
    if(nums[i]==note){
        count++;
    }
    else{
        count--;
        if(count<0){
            note=nums[i];
            count=1;
    }
}

}//of for
return note;
//题目默认存在，就不用验算啦

}

3.存在重复元素

/*bool containsDuplicate(int* nums, int numsSize) {
    for(int i=0;i<numsSize;i++){
        for(int j=i+1;j<numsSize;j++){
            if(nums[i]==nums[j]){
                return true;
            }
    }
    }
    return false;
}
*/
//我觉得按道理这样也可以，他非要说超时
int cmp(const void*a,const void*b){
    return *(int*)a-*(int*)b;
}
bool containsDuplicate(int* nums, int numsSize){
    qsort(nums,numsSize,sizeof(int),cmp);//对数组a进行排序
    for(int i=0;i<numsSize-1;i++){
        if(nums[i]==nums[i+1]){
            return true;
        }
    }
    return false;
}

4.最大间距

int cmp(const void* a,const void* b){
    return *(int *)a-*(int *)b;
}
int maximumGap(int* nums, int numsSize) {
    if(numsSize<2) return 0;
    qsort(nums,numsSize,sizeof(int),cmp);//快速排序数组nums[]
    int max=0;//记录最大差值

    for(int i=0;i<numsSize-1;i++){
        if(nums[i+1]-nums[i]>max){
            max=nums[i+1]-nums[i];
        }
    }
    return max;

}

5.按奇偶排序数组

/**
 * Note: The returned array must be malloced, assume caller calls free().
 */
自己：
int* sortArrayByParity(int* nums, int numsSize, int* returnSize) {
    * returnSize=numsSize;
    int *a=(int *)malloc(sizeof(int)*numsSize);//数组a用于记录偶数
    int *b=(int *)malloc(sizeof(int)*numsSize);//数组b用于记录奇数
    int j=0,k=0;
    for(int i=0;i<numsSize;i++){
        if(nums[i]&1){//奇数
            b[k++]=nums[i];
        }else{//偶数
            a[j++]=nums[i];
        }
    }//of for
    for(int i=0;i<j;i++){
        nums[i]=a[i];
    }
    for(int i=0;i<k;i++){
        nums[i+j]=b[i];
    }
    return nums;

}
//看了别人的感觉自己的方法好垃圾啊

方法二：奇数从后面记录，偶数从前面记录
int* sortArrayByParity(int* nums, int numsSize, int* returnSize) {
    int* ret=malloc(sizeof(int)*numsSize);
    *returnSize=numsSize;
    int begin=0,end=numsSize-1;
    for(int i=0;i<numsSize;i++){
        if(nums[i]%2==0){
            ret[begin++]=nums[i];
        }else{
            ret[end--]=nums[i];
        }
    }
    return ret;
}


方法三:直接定义奇偶排序
int cmp(const void* a,const void* b){
    return *(int *)a %2-*(int *)b %2;//偶数排前面
}
int* sortArrayByParity(int* nums, int numsSize, int* returnSize)  {
    
    qsort(nums,numsSize,sizeof(int),cmp);//快速排序数组nums[]
    *returnSize=numsSize;
    return nums;

}

6.最小时间差

int cmp(const void* a,const void* b){
    return *(int *)a-*(int *)b;
}
int findMinDifference(char** timePoints, int timePointsSize) {
    //基本思路：新建一个整形数组，将二维字符串数组转化，
    //然后排序
    //然后找到差值最大
    
    int* a=(int *)malloc(sizeof(int)*timePointsSize);
    for(int i=0;i<timePointsSize;i++){
        int h1=timePoints[i][0];//时针十位
        int h2=timePoints[i][1];//时针个位
        int h3=timePoints[i][3];//分针十位
        int h4=timePoints[i][4];//分针个位
        int h=(h1*10+h2)*60+h3*10+h4;//将所有时间转化成分钟数，方便计算分针差值
        a[i]=h;
    }

    qsort(a,timePointsSize,sizeof(int),cmp);//排序时间数组a
    int min=999999;//定义初始最小时间差
    for(int i=1;i<timePointsSize;i++){
        if(a[i]-a[i-1]<min){
            min=a[i]-a[i-1];
        }
        if(min>720){
            min=1440-min;
        }
    min= fmin(min, 1440 - (a[timePointsSize - 1] - a[0]));
//想想为什么要这样取，最小值，假如00:01 ,23:59,你看时间差是多少，
//直接减是不可以的，要取轮转24小时制，也就是两分钟

    }//of for
    return min;

}

加油加油，还有二十天复试，加油加油💪(ง •_•)ง！！