Ryxzzz
2018-01-07 02:20
采纳率: 100%
浏览 2.4k
已采纳

<求教>java算法带权数据求中位数的问题

给定一组数据,每个数据都有一定权重,请写算法计算中位数。用java实现
数值[0.5,1.24,18,1.4,2.1,3.2,2.5,13,2.6,18,2.55,1.2,1.83,1.3,2.1]
权重[0.8,0.2,1.98,1.4,2.1,3.8,2.1,2.12,0.5,5.6,1.1,1.2,3.5,1.2,1.5]
最好有代码,谢谢了

  • 写回答
  • 关注问题
  • 收藏
  • 邀请回答

6条回答 默认 最新

  • Howden081219 2018-01-07 05:33
    已采纳

    public class FindMdlInArray {

    public static void main(String args[])
    {
        double []num = {0.5,1.24,18,1.4,2.1,3.2,2.5,13,2.6,18,2.55,1.2,1.83,1.3,2.1};
        double []weight = {0.8,0.2,1.98,1.4,2.1,3.8,2.1,2.12,0.5,5.6,1.1,1.2,3.5,1.2,1.5};
        double tmp[] = new double[num.length];
    
        for (int i = 0; i < num.length; i++)
            tmp[i] = num[i] * weight[i];
    

    //

    // for (int k = 0; k < num.length; k++)
    // System.out.print(tmp[k] + " ");
    // System.out.println();

        double mld = getMdlInArray(tmp, num);
    
        System.out.println("位数 = " + mld);
    }
    
    public static double getMdlInArray(double array[], double num[])
    {
        double k;
        // 对array, num数组排序
        for (int i = 0; i < array.length; i++)
        {
            for (int j = 1; j < array.length - i; j++)
                if (array[j - 1] > array[j])
                {
                    k = array[j - 1];
                    array[j - 1] = array[j];
                    array[j] = k;
    
                    k = num[j - 1];
                    num[j - 1] = num[j];
                    num[j] = k;
                }
        }
    

    // for (int t = 0; t < num.length; t++)
    // System.out.print(array[t] + " ");
    // System.out.println();
    return num[(num.length-1)/2];
    }
    }

    已采纳该答案
    打赏 评论
  • threenewbee 2018-01-07 02:50
     float[] n = {0.5,1.24,18,1.4,2.1,3.2,2.5,13,2.6,18,2.55,1.2,1.83,1.3,2.1};
    float[] w = [0.8,0.2,1.98,1.4,2.1,3.8,2.1,2.12,0.5,5.6,1.1,1.2,3.5,1.2,1.5};
    double sum = 0.0, sum1 = 0.0, r = 0.0;
    for (int i = 0; i < n.length(); i++)
    sum += n[i] * w[i];
    for (int i = 0; i < n.length(); i++)
    if (sum1+ n[i] * w[i] >= sum / 2.0) { r = n[i]; break; }
    //r就是结果
    
    打赏 评论
  • threenewbee 2018-01-07 02:52

    带权中位数 = 累加后带权的总数的1/2的数。
    代码手工输入的,你参考下。如果问题得到解决,麻烦点下我回答右边的采纳,谢谢。

    打赏 评论
  • fwherr 2018-01-07 02:53

    实现思路:
    我们知道,在10以内的整数里,0~3出现的概率是0.3,3~6出现的概率是0.3,6~7出现的概率是0.1,7~9出现的概率是0.2,9~10出现的概率是0.1 ;上面对应的权重可对应为3 、3 、1、2 、1 。

    所以,当我们需要实现不知道权重到底是多少时,我们只需要将所有权重加起来,假设为100,然后让随机数只出现0到100,接着给每个权重设定一个区间段,权重有多大,该区间段就有多宽,其中总区间就是总权重。

    在组装我们的数据上也需要一定的技巧,我们用TreeMap来组装,key是区间段后面一个值,如下面0~4区间段对应的是4,然后将后面的值(如”4444“)放进value里。

    生成在总权重范围内的随机数,假设是2;然后我们根据TreeMap的ceilingKey(2) 方法获得大于等于2的最键,这里得到是4。这样就能去TreeMap里取到我们需要的值了

    打赏 评论
  • 陌殇尘墨 2018-05-18 01:25

    public class WeightedMedian {

    @Test
    public void main() throws Exception {
        double[] arrays={0.5,1.24,18,1.4,2.1,3.2,2.5,13,2.6,18,2.55,1.2,1.83,1.3,2.1};
        double[] weights={0.8,0.2,1.98,1.4,2.1,3.8,2.1,2.12,0.5,5.6,1.1,1.2,3.5,1.2,1.5};
        System.out.println(getMedian(arrays,weights));
    }
    
    /**
     * 求中位数
     * @param arrays 数值数组
     * @param weights 权重数组
     * @return 数值的带权中位数
     * @throws Exception 数值和权重数组长度不一致
     */
    private double getMedian(double[] arrays,double[] weights) throws Exception {
        double sum=0;
        double sum1=0;
        //检测数值和权重数组长度是否一致,不一致抛出异常
        if (arrays.length!=weights.length){
            throw new Exception("数值和权重数组长度不一致");
        }else {
            double[] results=new double[arrays.length];
            double[] resultsOfArrays=new double[arrays.length];
            for (int i=0;i<arrays.length;i++) {
                //求出数值和权重的乘积
                results[i] = arrays[i] * weights[i];
            }
            //求出sum
            for (int i=0;i<results.length;i++) {
                //求出带权数值的和
                sum+=results[i];
            }
            //进行数组拷贝,因为执行排序后根据java语言特性数组的顺序会该改变,无法通过下标去查找数值中的中位数
            System.arraycopy(results,0,resultsOfArrays,0,results.length);
            //通过快排进行排序
            quickSort(results,0,results.length-1);
            for (int i=0;i<results.length;i++){
                sum1+=results[i];
                if(sum1>=sum/2){
                    //求出中位数索引
                    int index=search(resultsOfArrays,results[i]);
                    return arrays[index];
                }
            }
    
        }
        return -1;//返回数值数组的中位数
    }
    
    /**
     * 快速排序实现
     * @param arrays 需要排序的数组
     * @param low 数组的低位下标
     * @param high 数组的高位下标
     */
    private void quickSort(double[] arrays,int low,int high){
        int i=low;
        int j=high;
        double tmp=arrays[low];
        while (low<high)
        {
            while ((low<high)&&(arrays[high]>=tmp))
            {
                high--;
            }
            arrays[low]=arrays[high];
            arrays[high]=tmp;
            low++;
            while ((low<high)&&(arrays[low]<=tmp))
            {
                low++;
            }
            if (low<high)
            {
                arrays[high]=arrays[low];
                arrays[low]=tmp;
                high--;
            }
        }
        if(i<low-1)
        {
            quickSort(arrays,i,low-1);
        }
        if(low<j)
        {
            quickSort(arrays,low,j);
        }
    }
    
    /**
     * 查找实现,此查找只用于此程序,所以在getMedian(double[] arrays,double[] weights)
     * 方法里没有做查找失败检测,因为此查找必然成功。
     * @param arrays 需要查找的数组
     * @param key 需要查找的值
     * @return 返回值所在的数组下标
     */
    private int search(double[] arrays,double key)
    {
        for (int i=0;i<arrays.length;i++){
            if(arrays[i]==key){
                return i;
            }
        }
        return -1;
    }
    

    }

    打赏 评论
  • 陌殇尘墨 2018-05-18 04:49

    我的上一个回答是错的,要注意带权中位数和普通中位数的不同

    public class WeightedMedian {

    @Test
    public void main() throws Exception {
        //进行排序arrays,weightsLast
        double[] arrays={0.5,1.24,18,1.4,2.1,3.2,2.5,13,2.6,18,2.55,1.2,1.83,1.3,2.1};
        double[] arraysBefore=new double[arrays.length];
        System.arraycopy(arrays,0,arraysBefore,0,arrays.length);
        double[] weights={0.8,0.2,1.98,1.4,2.1,3.8,2.1,2.12,0.5,5.6,1.1,1.2,3.5,1.2,1.5};
        double[] weightsLast=new double[weights.length];
        Arrays.sort(arrays);
        for (int i = 0; i < arrays.length; i++) {
            int index=search(arraysBefore,arrays[i]);
            weightsLast[i]=weights[index];
            arraysBefore[index]=-1;
        }
        System.out.println(getMedian(arrays,weightsLast));
    }
    
    /**
     *
     * @param arrays
     * @param weights
     * @return
     */
    private double getMedian(double[] arrays,double[] weights){
        double sum=0,sum1=0;
        for (int i = 0; i < weights.length; i++) {
            System.out.println("  "+i);
            sum+=weights[i];
        }
        for (int i = 0; i < weights.length; i++) {
            sum1+=weights[i];
            if (sum1>=sum/2){
                return arrays[i];
            }
        }
        return -1;
    }
    
    /**
     * 查找实现,此查找只用于此程序,所以在getMedian(double[] arrays,double[] weights)
     * 方法里没有做查找失败检测,因为此查找必然成功。
     * @param arrays 需要查找的数组
     * @param key 需要查找的值
     * @return 返回值所在的数组下标
     */
    private int search(double[] arrays,double key)
    {
        for (int i=0;i<arrays.length;i++){
            if(arrays[i]==key){
                return i;
            }
        }
        return -1;
    }
    

    }

    打赏 评论

相关推荐 更多相似问题