leecode-C语言实现-1619. 删除某些元素后的数组均值

已于 2022-03-03 09:27:20 修改
阅读量705 收藏
点赞数 3
分类专栏： # leecode练习-c语言实现 文章标签： 排序算法 算法 c语言 leetcode c算法
于 2022-02-24 11:32:20 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45111959/article/details/123107573
版权

一、题目
在这里插入图片描述
在这里插入图片描述
二、解题思路
（1）方法一之计数法
通过题目要求0 <= arr[i] <= 10的5次方，元素最大值为100000，最小值为0，我们可以初始化一个长度为100000的数组b，记录题目中给的数组a中各元素出现的值。在遍历数组b中的元素，剔除前百分之五x和后百分之五y，例如判断前百分之五时，需要考虑x小于、等于、大于第一个下标不为0的情况，我这里不建议大家使用这种方法，
第一：效率一般。
第二：判断逻辑有些复杂，代码不清晰，比较绕。
举例：
数组a：
数据：1，2，2，2，2，2，2，2，2，2，2，2，2，2，2，2，2，2，2，3

数组b：
索引：0，1，2，3，4，5，6，7，8，。。。。。。。。。。。。。。。
数据：0，1,18，0，0，0，0，0，0，。。。。。。。。。。。。。。。

（2）方法二之排序法–冒泡
将题目中给的数组a进行排序，取5%到95%之的值，再算平均数，但排序效率没有自带库函数qsort效率高。

（3）方法二之排序法–qsort

三、虚机测试代码

#include <stdio.h>
#include <stdlib.h>
#include <math.h>

void main()
{
    double trimMean(int* arr, int arrSize);
    void PrintfArr(int *arr, int size);
    unsigned int arr[] = {1,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,3};
    int arrSize = sizeof(arr) / sizeof(int);

    //PrintfArr(arr, arrSize);
    printf("%f\n",trimMean(arr, arrSize));
}

/*
20 <= arr.length <= 1000
arr.length 是 20 的 倍数 
0 <= arr[i] <= 10的5次方
*/

double trimMean(int* arr, int arrSize)
{
    int Compare(const void *p1, const void *p2);
    int i;
    double sum = 0;
    qsort(arr,arrSize,sizeof(int),Compare);
    for(i=0; i<(arrSize-arrSize/20); i++)
    {
        if(i >= arrSize/20)
        {
            sum += (double)arr[i];
        }
    }
    return sum / (double)(arrSize - arrSize / 20 * 2);
}

int Compare(const void *p1, const void *p2)
{
   int *ps1 = (int*)p1;
   int *ps2 = (int*)p2;
   return *ps1 - *ps2;
}

/*
double trimMean(int* arr, int arrSize)
{
    void bubble_sort_func_v0(int *array,int num);
    int i;
    int tmp = arrSize/20;
    double sum = 0;
    double cnt = (double)(arrSize - tmp * 2);
    bubble_sort_func_v0(arr,arrSize);

    for(i=0; i<(arrSize-tmp); i++)
    {
        if(i >= tmp)
        {
            sum = (double)arr[i] + sum;
            printf("index: %d, sum : %f, cnt : %f\n",i,sum,cnt);
        }    
    }
    return sum / cnt;
}

void bubble_sort_func_v0(int *array,int num)
{
    int i,j,temp_var;

    for(i=0;i<num-1;i++)
    {
        for(j=0;j<num-i-1;j++)
        {
            if(*(array+j)>*(array+j+1))
            {
                temp_var = *(array+j);
                *(array+j) = *(array+j+1);
                *(array+j+1) = temp_var;
            }
        }
    }
}
*/

/*
double trimMean(int* arr, int arrSize)
{
    void PrintfArr(int *arr, int size);

    int size = 100001;
    //int size = 11;
    unsigned int *arr_res = malloc(sizeof(int) * size);
    unsigned int cnt = 0;
    unsigned int sum = 0;
    unsigned int tmp = 0;
    unsigned int tmp1 = 0;
    int flg = 0;
    int m = 0;
    int i;
    unsigned int TmpArr[4] = {0};
    //TmpArr数组中分别存储着前百分之5的值、前百分之5值的个数、后百分之5的值、后百分之5值的个数
    TmpArr[1] = arrSize / 20;
    TmpArr[3] = arrSize - TmpArr[1];
     
    for(i<0; i<size; i++)
    {
        arr_res[i] = 0;
    }

    for(i=0; i<arrSize; i++)
    {
        arr_res[arr[i]]++;
    }

    for(i=0; i<size; i++)
    {
        if(arr_res[i] != 0)
        {
            printf("i : %d, arr_res[i] : %d, cnt : %d, sum : %d, TmpArr[1] : %d, TmpArr[3] : %d, tmp : %d, tmp1 : %d\n",i,arr_res[i],cnt,sum,TmpArr[1],TmpArr[3],tmp,tmp1);
            cnt = cnt + arr_res[i];
            sum = sum + (i * arr_res[i]);
            if(cnt < TmpArr[1] && (tmp == 0))
            {
                 printf("cnt < TmpArr[1] && (tmp == 0)\n");
                 TmpArr[0] = i * arr_res[i] + TmpArr[0];
                 tmp =  TmpArr[1] - arr_res[i] - tmp;
            }
            else if(cnt < TmpArr[1] && (tmp != 0))
            {
                 printf("cnt < TmpArr[1] && (tmp != 0)\n");
                 TmpArr[0] = i * arr_res[i] + TmpArr[0];
                 tmp =  tmp - arr_res[i];
            }
            else if(cnt == TmpArr[1] && (m == 0))
            {
                 printf("cnt == TmpArr[1]  && (m == 0)\n");
                 tmp =  0;
                 TmpArr[0] = i * arr_res[i] + TmpArr[0];
                 m = m + 1;
            }
            else if((cnt > TmpArr[1]) && (tmp != 0))
            {
                 printf("(cnt > TmpArr[1]) && (tmp != 0)\n");    
                 TmpArr[0] = i * tmp + TmpArr[0];
                 tmp = 0;
            }
            else if((cnt > TmpArr[1]) && (tmp == 0) && (m == 0))
            {
                 printf("(cnt > TmpArr[1]) && (tmp == 0) && (m == 0)\n");
                 TmpArr[0] = i * arr_res[i];
                 m = m + 1;
            }
            else if(cnt == TmpArr[3])
            {
                 printf("cnt == TmpArr[3]\n");
                 flg = 1;
            }
            else if((cnt > TmpArr[3]) && flg)
            {
                 printf("(cnt > TmpArr[3]) && flg\n");    
                 TmpArr[2] = i * arr_res[i] + TmpArr[2];
            }
            else if((cnt > TmpArr[3]) && (!flg))
            {
                 printf("(cnt > TmpArr[3]) && (!flg)\n");
                 tmp1 = cnt - TmpArr[3] - tmp1;
                 TmpArr[2] = i * tmp1 + TmpArr[2];
            }
            printf("i : %d, arr_res[i] : %d, cnt : %d, sum : %d, TmpArr[1] : %d, TmpArr[3] : %d, tmp : %d, tmp1 : %d\n",i,arr_res[i],cnt,sum,TmpArr[1],TmpArr[3],tmp,tmp1);
            printf("TmpArr[0] : %d, TmpArr[2] : %d\n",TmpArr[0],TmpArr[2]);
            printf("**********************\n");
        }
    }
    sum = sum - TmpArr[0] - TmpArr[2];
    cnt = cnt - TmpArr[1] - TmpArr[1];
    return (double)sum / (double)cnt;
}
*/

void PrintfArr(int *arr, int size)
{
    int i;
    for(i=0; i<size; i++)
    {
        printf("index: %3d, val : %3d\n",i,arr[i]);
    }
    printf("=============\n");
}

四、虚机测试截图
在这里插入图片描述

五、leecode提交代码
（1）方法一

double trimMean(int* arr, int arrSize)
{
    //void PrintfArr(int *arr, int size);

    int size = 100001;
    //int size = 11;
    unsigned int *arr_res = malloc(sizeof(int) * size);
    unsigned int cnt = 0;
    unsigned int sum = 0;
    unsigned int tmp = 0;
    unsigned int tmp1 = 0;
    int flg = 0;
    int m = 0;
    int i;
    unsigned int TmpArr[4] = {0};
    //TmpArr数组中分别存储着前百分之5的值、前百分之5值的个数、后百分之5的值、后百分之5值的个数
    TmpArr[1] = arrSize / 20;
    TmpArr[3] = arrSize - TmpArr[1];
     
    for(i<0; i<size; i++)
    {
        arr_res[i] = 0;
    }

    for(i=0; i<arrSize; i++)
    {
        arr_res[arr[i]]++;
    }

    for(i=0; i<size; i++)
    {
        if(arr_res[i] != 0)
        {
            //printf("i : %d, arr_res[i] : %d, cnt : %d, sum : %d, TmpArr[1] : %d, TmpArr[3] : %d, tmp : %d, tmp1 : %d\n",i,arr_res[i],cnt,sum,TmpArr[1],TmpArr[3],tmp,tmp1);
            cnt = cnt + arr_res[i];
            sum = sum + (i * arr_res[i]);
            if(cnt < TmpArr[1] && (tmp == 0))
            {
                 //printf("cnt < TmpArr[1] && (tmp == 0)\n");
                 TmpArr[0] = i * arr_res[i] + TmpArr[0];
                 tmp =  TmpArr[1] - arr_res[i] - tmp;
            }
            else if(cnt < TmpArr[1] && (tmp != 0))
            {
                 //printf("cnt < TmpArr[1] && (tmp != 0)\n");
                 TmpArr[0] = i * arr_res[i] + TmpArr[0];
                 tmp =  tmp - arr_res[i];
            }
            else if(cnt == TmpArr[1] && (m == 0))
            {
                 //printf("cnt == TmpArr[1]  && (m == 0)\n");
                 tmp =  0;
                 TmpArr[0] = i * arr_res[i] + TmpArr[0];
                 m = m + 1;
            }
            else if((cnt > TmpArr[1]) && (tmp != 0))
            {
                 //printf("(cnt > TmpArr[1]) && (tmp != 0)\n");    
                 TmpArr[0] = i * tmp + TmpArr[0];
                 tmp = 0;
            }
            else if((cnt > TmpArr[1]) && (tmp == 0) && (m == 0))
            {
                 //printf("(cnt > TmpArr[1]) && (tmp == 0) && (m == 0)\n");
                 TmpArr[0] = i * arr_res[i];
                 m = m + 1;
            }
            else if(cnt == TmpArr[3])
            {
                 //printf("cnt == TmpArr[3]\n");
                 flg = 1;
            }
            else if((cnt > TmpArr[3]) && flg)
            {
                 //printf("(cnt > TmpArr[3]) && flg\n");    
                 TmpArr[2] = i * arr_res[i] + TmpArr[2];
            }
            else if((cnt > TmpArr[3]) && (!flg))
            {
                 //printf("(cnt > TmpArr[3]) && (!flg)\n");
                 tmp1 = cnt - TmpArr[3] - tmp1;
                 TmpArr[2] = i * tmp1 + TmpArr[2];
            }
            //printf("i : %d, arr_res[i] : %d, cnt : %d, sum : %d, TmpArr[1] : %d, TmpArr[3] : %d, tmp : %d, tmp1 : %d\n",i,arr_res[i],cnt,sum,TmpArr[1],TmpArr[3],tmp,tmp1);
            //printf("TmpArr[0] : %d, TmpArr[2] : %d\n",TmpArr[0],TmpArr[2]);
            //printf("**********************\n");
        }
    }
    sum = sum - TmpArr[0] - TmpArr[2];
    cnt = cnt - TmpArr[1] - TmpArr[1];
    return (double)sum / (double)cnt;
}

（2）方法二

double trimMean(int* arr, int arrSize)
{   
    void bubble_sort_func_v0(int *array,int num);
    int i;
    int tmp = arrSize/20;
    double sum = 0;
    double cnt = (double)(arrSize - tmp * 2);
    bubble_sort_func_v0(arr,arrSize);
    
    for(i=0; i<(arrSize-tmp); i++)
    {   
        if(i >= tmp)
        {   
            sum = (double)arr[i] + sum;
            //printf("index: %d, sum : %f, cnt : %f\n",i,sum,cnt);
        }
    }
    return sum / cnt;
}

void bubble_sort_func_v0(int *array,int num)
{
    int i,j,temp_var;

    for(i=0;i<num-1;i++)
    {
        for(j=0;j<num-i-1;j++)
        {
            if(*(array+j)>*(array+j+1))
            {
                temp_var = *(array+j);
                *(array+j) = *(array+j+1);
                *(array+j+1) = temp_var;
            }
        }
    }
}

（3）方法三

double trimMean(int* arr, int arrSize)
{
    int Compare(const void *p1, const void *p2);
    int i;
    double sum = 0;
    qsort(arr,arrSize,sizeof(int),Compare);
    for(i=0; i<(arrSize-arrSize/20); i++)
    {
        if(i >= arrSize/20)
        {
            sum += (double)arr[i];
        }
    }
    return sum / (double)(arrSize - arrSize / 20 * 2);
}

int Compare(const void *p1, const void *p2)
{
   int *ps1 = (int*)p1;
   int *ps2 = (int*)p2;
   return *ps1 - *ps2;
}

六、leecode提交截图
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

阳光九叶草LXGZXJ
关注
  • 3
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
中国科技大学-C语言讲义7ppt课件.ppt
11-20
在C语言中，数组是一组有序数据的集合，每个元素的类型相同。用数组名和下标来唯一确定数组中的元素。 数组的定义 数组的定义方式有多种，例如： * `int a[10];`，定义了一个整型数组a，包含10个元素。 * `float ...
C语言数组-C语言实现使用静态数组实现循环队列.zip
03-02
循环队列是一种线性数据结构，它巧妙地利用了数组的特性，克服了普通队列在满时无法插入元素、空时无法删除元素的问题。 首先，了解数组的基本概念。数组是一系列相同类型的元素在内存中连续存储的集合，可以通过索...
【LeetCode】1619. 删除某些元素后的数组均值（C++）
敲代码两年半的练习生博客
02-27 1288
1619. 删除某些元素后的数组均值（C++）1 题目描述2 示例描述2.1 示例 22.2 示例 22.3 示例 32.4 示例 42.5 示例 53 解题提示4 解题思路5 源码详解（C++） 1 题目描述 给你一个整数数组 arr ，请你删除最小 5% 的数字和最大 5% 的数字后，剩余数字的平均值。 与 标准答案 误差在 10^-5 的结果都被视为正确结果。 2 示例描述 2.1 示例 2 输入：arr = [1,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,3] 输
LeetCode1619.删除某些元素后的数组均值（Java）
Fiona20的博客
12-08 265
给你一个整数数组 arr ，请你删除最小 5% 的数字和最大 5% 的数字后，剩余数字的平均值。 与 标准答案 误差在 10-5 的结果都被视为正确结果。
LeetCode1619删除某些元素后的数组均值(java)
weixin_43170297的博客
10-19 162
class Solution { public double trimMean(int[] arr) { Arrays.sort(arr); int len = arr.length; int start = len / 20, end = len - len / 20; double sum = 0; for(int i = start;i < end; i++) { sum += a..
1619.删除某些元素后的数组均值
stay_awake__的博客
09-15 171
排序的应用
Leetcode.1619删除某些元素后的均值
不是老哥的博客
03-31 142
Leetcode.1619删除某些元素后的均值 题目难度：简单 题目：原题链接 思路 1、这道题竟然没有几个人，打卡，说明这道题不重要，可以忽略； 2、题目是求删除最小百分之5的数和最大百分之五的数之后均值； 3、先对数组进行排序； 4、计算前百分之5元素的下标值m,后百分之五的下标起始位置为：arr.length - m ； 5、遍历从m 到 arr.lenfth - m ,求和； 6、元素个数为arr.length -2m ； class Solution { public double tr
C语言开发----c语言涂格子游戏源码.rar
04-10
在本资源"C语言开发----c语言涂格子游戏源码.rar"中，我们可以探索一个基于C语言实现的小型游戏——涂格子游戏。C语言是一种基础且强大的编程语言，广泛用于系统开发、软件构建以及各种游戏开发。这个游戏的源代码为...
C语言数组-C语言实现使用动态数组来构建栈结构.zip
03-02
在C语言中，数组是一种非常基础且重要的数据结构，它允许程序员存储一组具有相同类型的数据。数组在内存中是连续存储的，通过索引访问数组元素是高效且直接的。本教程将聚焦于如何利用C语言中的动态数组来构建栈...
C语言数组-C语言实现使用动态数组来构建循环链表.zip
03-02
在“C语言数组_C语言实现使用动态数组来构建循环链表”这个主题中，我们将探讨如何使用动态数组来实现循环链表的主要步骤： 1. **定义节点结构体**：首先，我们需要定义一个结构体来表示链表节点，通常包括数据域和...
【教3妹学算法】特殊数组的特征值
kangbin825的专栏
09-12 227
哎，又到周一了，不想上班不想上班，什么时候能到周五啊。：这才周一就想着周五了，还早呢。周末休息了两天，今天应该精力充沛才对啊。：哎，不上班行不行啊。：不上班你养我啊？：我问的是我不上班行不行，不是你不上班行不行！！！：嘿嘿嘿，那你不说清楚。：不跟你聊了，去上班去了，2哥还不去吗。：我上班时间比较晚，先做一道算法题再说。
c语言 --- 基本数据类型
weixin_60569662的博客
03-02 2308
0000 0000 0000 0000 0000 0000 0000 0000 //进位处理（寄存器有一个标志位处理）原码:1000 0000 0000 0000 0000 0000 0000 0011 //引入符号,最高位表示符号位。二进制：二进制表示3 0---0 1---1 10---2 11---3 满 2 进 1。原码:0000 0000 0000 0000 0000 0000 0000 0011。驼峰：playMusicByUser--->一般使用这一种命名方式，首字母小写。
C语言 · 五次方数
weixin_34277853的博客
02-26 1138
算法提高 五次方数   时间限制：1.0s   内存限制：256.0MB      问题描述 　　对一个数十进制表示时的每一位数字乘五次方再求和，会得到一个数的五次方数　　例如：1024的五次方数为1+0+32+1024=1057　　有这样一些神奇的数，它的五次方数就是它自己，而且这样的数竟然只有有限多个　　从小到大输出所有这样的数 输出格式 　　每个数独立一行输出 样例输出 1020030...
C语言 深度探究C语言中的数组
小鹏AI
11-28 1252
由于数组名就是一个指针，如果只传数组名，那么函数只知道数组开始的地址，不知道结束的地址，所以才需要把数组长度也一起传入。反过来，通过数组的减法，可以知道两个地址之间有多少个数组成员，请看下面的例子，自己实现一个计算数组长度的函数。上面示例中，将某个数组成员的地址，减去数组起始地址，就可以知道，当前成员与起始地址之间有多少个成员。声明数组时，编译器自动为数组分配了内存地址，这个地址与数组名是绑定的，不可更改，下面的代码会报错。省略成员数量时，如果同时采用指定位置的赋值，那么数组长度将是最大的指定位置再加1。
数组求和
xiezhongtian的专栏
12-02 806
#include int sum(int *arr, int n){ return n == 0 ? 0 : sum(arr,n-1) + arr[n-1]; } int main(){ int arr[] = {1,2,3,4,5,6,7,8,9,10}; int len = sizeof(arr)/sizeof(arr[0]);
Python 每日一记277@顺序表插入/删除元素平均移动次数
教练我想学编程
06-02 3699
以数组为基础，假设有n个元素，插入元素时，在第一个元素前插入元素，n个元素都要向后移动一位，在第二个元素前插入元素，后面的n-1个元素后移，在第i个元素前插入元素，n-i+1个元素需要后移，在最后一个元素后插入元素，0个元素需要后移动，pi为在i前插入元素的概率，因为第几个元素的概率相同，因此pi=1/(n+1)，即元素总数的倒数。 删除元素时，删除第一个元素，n-1个元素前移，删除第二个元素，n-2个元素前移，删除第i个元素，n-i个元素前移，删除最后一个元素，0个元素前移，pi为删除第i个元素的概率，因
HP 打印机驱动安装Return code:1603解决办法
热门推荐
jacke121的专栏
08-30 1万+
HP 打印机驱动安装Return code:1603解决办法 计算机图标——右键选择管理——服务和应用程序——服务——print spooler双击——启动类型修改为自动——并点击启动——应用——确定 我的电脑到这已经解决 开启服务的方法： 右击桌面的此电脑——>点击管理——>点击左侧栏中的服务与应用程序——>再点击右侧的服务即可出现 在服务中找到print ...
数据结构与算法——排序算法
最新发布
weixin_45942515的博客
07-19 781
插入排序属于内部式排序法，是对于欲排序的元素以插入的方式找寻该元素的适当位置，以达到排序的目的。希尔排序是希尔 (Donald shell)于1959年提出的一种排序算法。希尔排序也是一种插入排序。它是简单插入排序经过改进之后的一个更高效的版本，也称为缩小增量排序。快速排序(quickSort)是对冒泡排序的一种改进。基本思想是：通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据要小，然后再按照此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值