java 计算中位数的实现方法

最近工作需要 要求把python的代码写成java版本,python中有一个np.median()求中位数的方法,java决定手写一个

先说说什么是中位数:

中位数就是中间的那个数,

如果一个集合是奇数个,那么中位数就是按大小排列后,最中间那个数,

如果一个集合是偶数个,那么中位数就是按大小排列后,最中间那2个数的平均数。

比如:

1,2,3,4,5 那中位数就是3

1,2,3,4,5,6 那中位数就是 (3+4)/2 = 3.5

知道逻辑后方法就很简单了 下面是代码

public static void main(String[] args) {
 List<Integer> total = new ArrayList<Integer>();
 total.add(4);
 total.add(2);
 total.add(3);
 total.add(1);
 total.add(5);
 total.add(6);
 double a = median(total);
 System.out.println(a);
}
private static double median(List<Integer> total) {
 double j = 0;
 //集合排序
  Collections.sort(total);
  int size = total.size();
  if(size % 2 == 1){
   j = total.get((size-1)/2);
  }else {
   //加0.0是为了把int转成double类型,否则除以2会算错
   j = (total.get(size/2-1) + total.get(size/2) + 0.0)/2;
  }
 return j;
}

1. 方法内先判断集合是奇数还是偶数,如果是奇数那么就是第n+1/2个数 ,也就是下标为n-1/2的值,

如果是偶数 就是第n/2和n/2+1的数的平均值 也就是下标为n/2-1和n/2的平均值

2. 该方法传入的是list集合 如果为数组 可以先用Arrays.aslist()方法转换后传入

补充知识:Java计算中位数、方差、标准差、众数

我就废话不多说了,大家还是直接看代码吧~


import java.text.DecimalFormat;
import java.util.*;

/**
 * 数学算法(数学算法(方差、标准差、中位数、众数))
 * @author
 *
 */
public class MathAlgorithm {
	private final static double dmax = 999;// Double.MAX_VALUE;//Double类型的最大值,太大的double值,相乘会达到无穷大
	private final static double dmin = Double.MIN_VALUE;// Double类型的最小值
	private final static int n = 100;// 假设求取100个doubl数的方差和标准差

	public static void main(String[] args) {
		Random random = new Random();
		double[] x = new double[n];
		for (int i = 0; i < n; i++) {// 随机生成n个double数
			x[i] = Double.valueOf(Math.floor(random.nextDouble() * (dmax - dmin)));
			System.out.println(x[i]);
		}
		// 设置doubl字符串输出格式,不以科学计数法输出
		DecimalFormat df = new DecimalFormat("#,##0.00");// 格式化设置
		// 计算方差
		double dV = getVariance(x);
		System.out.println("方差=" + df.format(dV));
		// 计算标准差
		double dS = getStandardDiviation(x);
		System.out.println("标准差=" + df.format(dS));

		int[] intArr={5,10,15,8,6};
		System.out.println(Arrays.toString(intArr)+" 中位数:"+median(intArr));

		int[] intArr2={5,10,15,8,6,7};
		System.out.println(Arrays.toString(intArr2)+" 中位数:"+median(intArr2));

		int[] arr = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 1, 1, 2, 2, 3, 4, 5};

    List<Integer> modalNums = getModalNums(arr);
    System.out.println("众数:"+modalNums);

    float[] arr2 = {0.1f, 1.1f, 2.1f, 3.1f, 4.1f, 5.1f, 6.1f, 7.1f, 8.1f, 9.1f, 10.1f, 1.1f, 1.1f, 2.1f, 2.1f, 3.1f, 4.1f, 5.1f};

    List<Float> modalNums2 = getModalNums(arr2);

    System.out.println("众数:"+modalNums2);
	}

	/**
	 * 方差s^2=[(x1-x)^2 +...(xn-x)^2]/n
	 * @param x
	 * @return
	 */
	public static double getVariance(double[] x) {
		int m = x.length;
		double sum = 0;
		for (int i = 0; i < m; i++) {// 求和
			sum += x[i];
		}
		double dAve = sum / m;// 求平均值
		double dVar = 0;
		for (int i = 0; i < m; i++) {// 求方差
			dVar += (x[i] - dAve) * (x[i] - dAve);
		}
		return dVar / m;
	}

	/**
	 * 标准差σ=sqrt(s^2)
	 * @param x
	 * @return
	 */
	public static double getStandardDiviation(double[] x) {
		int m = x.length;
		double sum = 0;
		for (int i = 0; i < m; i++) {// 求和
			sum += x[i];
		}
		double dAve = sum / m;// 求平均值
		double dVar = 0;
		for (int i = 0; i < m; i++) {// 求方差
			dVar += (x[i] - dAve) * (x[i] - dAve);
		}
		return Math.sqrt(dVar / m);
	}

	/**
	 * 中位数(int)
   * @param nums: A list of integers.
   * @return: An integer denotes the middle number of the array.
   */
  public static int median(int []nums){
		if(nums.length==0)
			return 0;
		int start=0;
		int end=nums.length-1;
		int index=partition(nums, start, end);
		if(nums.length%2==0){
			while(index!=nums.length/2-1){
				if(index>nums.length/2-1){
					index=partition(nums, start, index-1);
				}else{
					index=partition(nums, index+1, end);
				}
			}
		}else{
			while(index!=nums.length/2){
				if(index>nums.length/2){
					index=partition(nums, start, index-1);
				}else{
					index=partition(nums, index+1, end);
				}
			}
		}
		return nums[index];
	}

	private static int partition(int nums[], int start, int end){
		int left=start;
		int right=end;
		int pivot=nums[left];
		while(left<right){
			while(left<right&&nums[right]>=pivot){
				right--;
			}
			if(left<right){
				nums[left]=nums[right];
				left++;
			}
			while(left<right&&nums[left]<=pivot){
				left++;
			}
			if(left<right){
				nums[right]=nums[left];
				right--;
			}
		}
		nums[left]=pivot;
		return left;
	}

	/**
	 * 中位数(float)
   * @param nums: A list of integers.
   * @return: An integer denotes the middle number of the array.
   */
  public static float median(float []nums){
		if(nums.length==0)
			return 0;
		int start=0;
		int end=nums.length-1;
		int index=partition(nums, start, end);
		if(nums.length%2==0){
			while(index!=nums.length/2-1){
				if(index>nums.length/2-1){
					index=partition(nums, start, index-1);
				}else{
					index=partition(nums, index+1, end);
				}
			}
		}else{
			while(index!=nums.length/2){
				if(index>nums.length/2){
					index=partition(nums, start, index-1);
				}else{
					index=partition(nums, index+1, end);
				}
			}
		}
		return nums[index];
	}

	private static int partition(float nums[], int start, int end){
		int left=start;
		int right=end;
		float pivot=nums[left];
		while(left<right){
			while(left<right&&nums[right]>=pivot){
				right--;
			}
			if(left<right){
				nums[left]=nums[right];
				left++;
			}
			while(left<right&&nums[left]<=pivot){
				left++;
			}
			if(left<right){
				nums[right]=nums[left];
				right--;
			}
		}
		nums[left]=pivot;
		return left;
	}

	/**
	 * 众数(int)
	 * 众数:在一个数组中出现次数最多的数
	 * 如果存在多个众数,则一起返回
	 * @param arr
	 * @return
	 */
	public static List<Integer> getModalNums(int[] arr) {
    int n = arr.length;

    if (n == 0) {
      return new ArrayList<Integer>();
    }

    if (n == 1) {
      return Arrays.asList(arr[0]);
    }

    Map<Integer, Integer> freqMap = new HashMap<>();
    for (int i = 0; i < n; i++) { // 统计数组中每个数出现的频率
      Integer v = freqMap.get(arr[i]);
      // v == null 说明 freqMap 中还没有这个 arr[i] 这个键
      freqMap.put(arr[i], v == null ? 1 : v + 1);
    }

    // 将 freqMap 中所有的键值对(键为数,值为数出现的频率)放入一个 ArrayList
    List<Map.Entry<Integer, Integer>> entries = new ArrayList<>(freqMap.entrySet());
    // 对 entries 按出现频率从大到小排序
    Collections.sort(entries, new Comparator<Map.Entry<Integer, Integer>>() {
      @Override
      public int compare(Map.Entry<Integer, Integer> e1, Map.Entry<Integer, Integer> e2) {
        return e2.getValue() - e1.getValue();
      }
    });

    List<Integer> modalNums = new ArrayList<>();
    modalNums.add(entries.get(0).getKey()); // 排序后第一个 entry 的键肯定是一个众数

    int size = entries.size();
    for (int i = 1; i < size; i++) {
      // 如果之后的 entry 与第一个 entry 的 value 相等,那么这个 entry 的键也是众数
      if (entries.get(i).getValue().equals(entries.get(0).getValue())) {
        modalNums.add(entries.get(i).getKey());
      } else {
        break;
      }
    }

    return modalNums;
  }

	/**
	 * 众数(float)
	 * 众数:在一个数组中出现次数最多的数
	 * 如果存在多个众数,则一起返回
	 * @param arr
	 * @return
	 */
	public static List<Float> getModalNums(float[] arr) {
    int n = arr.length;

    if (n == 0) {
      return new ArrayList<Float>();
    }

    if (n == 1) {
      return Arrays.asList(arr[0]);
    }

    Map<Float, Integer> freqMap = new HashMap<>();
    for (int i = 0; i < n; i++) { // 统计数组中每个数出现的频率
      Integer v = freqMap.get(arr[i]);
      // v == null 说明 freqMap 中还没有这个 arr[i] 这个键
      freqMap.put(arr[i], v == null ? 1 : v + 1);
    }

    // 将 freqMap 中所有的键值对(键为数,值为数出现的频率)放入一个 ArrayList
    List<Map.Entry<Float, Integer>> entries = new ArrayList<>(freqMap.entrySet());
    // 对 entries 按出现频率从大到小排序
    Collections.sort(entries, new Comparator<Map.Entry<Float, Integer>>() {
      @Override
      public int compare(Map.Entry<Float, Integer> e1, Map.Entry<Float, Integer> e2) {
        return e2.getValue() - e1.getValue();
      }
    });

    List<Float> modalNums = new ArrayList<>();
    modalNums.add(entries.get(0).getKey()); // 排序后第一个 entry 的键肯定是一个众数

    int size = entries.size();
    for (int i = 1; i < size; i++) {
      // 如果之后的 entry 与第一个 entry 的 value 相等,那么这个 entry 的键也是众数
      if (entries.get(i).getValue().equals(entries.get(0).getValue())) {
        modalNums.add(entries.get(i).getKey());
      } else {
        break;
      }
    }

    return modalNums;
  }
}

以上这篇java 计算中位数的实现方法就是小编分享给大家的全部内容了,希望能给大家一个参考,也希望大家多多支持我们。

(0)

相关推荐

  • 在java中获取List集合中最大的日期时间操作

    取List集合中最大的日期, 可以用Date max = Collections.max(dateList);, 传入一个日期集合, 就可以获取, 工作中有这个需求, 就查找到这个, 代码如下 } else { /** 获取此专题下的所有内容的最新时间 */ Long featureId = this.communityFeatureMapper.selectFeatureIdByLabelId(labelId); List<CommunityFeatureRelation> communit

  • JAVA实现按时间段查询数据操作

    html / jsp <span style="vertical-align: -webkit-baseline-middle;font-size:16px;font-weight:bold;">开始时间:</span>  <input name="startTime" id="startTime" type="text" class="Wdate" onfocus="

  • java 实现当前时间加减30分钟的时间代码

    如代码所示: SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"); Date now = new Date(); System.out.println("当前时间:" + sdf.format(now)); 方法一: long time = 30*60*1000;//30分钟 Date afterDate = new Date(now .getTime() + time);//30分钟

  • Java后台通过Collections获取list集合中最大数,最小数代码

    我就废话不多说了,大家还是直接看代码吧~ package com.jalor; import java.util.ArrayList; import java.util.Collections; import java.util.List; public class Jalor_20180728 { public static void main(String[] args) { List<Integer> rst2 = new ArrayList<>(); rst2.add(1)

  • java 计算中位数的实现方法

    最近工作需要 要求把python的代码写成java版本,python中有一个np.median()求中位数的方法,java决定手写一个 先说说什么是中位数: 中位数就是中间的那个数, 如果一个集合是奇数个,那么中位数就是按大小排列后,最中间那个数, 如果一个集合是偶数个,那么中位数就是按大小排列后,最中间那2个数的平均数. 比如: 1,2,3,4,5 那中位数就是3 1,2,3,4,5,6 那中位数就是 (3+4)/2 = 3.5 知道逻辑后方法就很简单了 下面是代码 public static

  • java计算百分比值的方法

    本文实例讲述了java计算百分比值的方法.分享给大家供大家参考.具体实现方法如下: public class Test1 { public static String myPercent(int y, int z) { String baifenbi = "";// 接受百分比的值 double baiy = y * 1.0; double baiz = z * 1.0; double fen = baiy / baiz; // NumberFormat nf = NumberForm

  • Java计算黑洞数的方法示例

    本文实例讲述了Java计算黑洞数的方法.分享给大家供大家参考,具体如下: 任意一个5位数,比如:34256,把它的各位数字打乱,重新排列,可以得到一个最大的数:65432,一个最小的数23456.求这两个数字的差,得:41976,把这个数字再次重复上述过程(如果不足5位,则前边补0).如此往复,数字会落入某个循环圈(称为数字黑洞). 比如,刚才的数字会落入:[82962,75933, 63954, 61974]这个循环圈. 请编写程序,找到5位数所有可能的循环圈,并输出,每个循环圈占1行.其中5

  • java计算时间差的方法

    本文实例讲述了java计算时间差的方法.分享给大家供大家参考.具体如下: /** * 计算时间差 * @param begin * @param end * @return 返回格式,"hh:mm:ss" */ public String getTimeDifference(Date begin,Date end) { long between=(end.getTime()-begin.getTime())/1000; //除以1000是为了转换成秒 long hour=between

  • java计算给定字符串中出现次数最多的字母和该字母出现次数的方法

    本文实例讲述了java计算给定字符串中出现次数最多的字母和该字母出现次数的方法.分享给大家供大家参考,具体如下: import Java.util.Collections; import java.util.Map; import java.util.TreeMap; public class TestStringSplict { public static void main(String[] args){ String str = "aaaaaaacccccccccccccccccccccc

  • java计算两个时间相差天数的方法汇总

    问题描述: 输入:两个日期 输出:两个日期相差的天数 具体代码实现 方法1: 通过Calendar类的日期比较.注意:这里需要考虑一下: 日期是跨年份的,如一个是2012年,一个是2015年的 年份是分闰年和平年的,各自的天数不同 /** * date2比date1多的天数 * @param date1 * @param date2 * @return */ public static int differentDays(Date date1,Date date2) { Calendar cal

  • Java计算交集,差集,并集的方法示例

    本文实例讲述了Java计算交集,差集,并集的方法.分享给大家供大家参考,具体如下: package math; import java.util.HashSet; import java.util.Set; public class Test { public static void main(String[] args) { Set<Integer> result = new HashSet<Integer>(); Set<Integer> set1 = new Ha

  • Java中使用LocalDate根据日期来计算年龄的实现方法

    Java中和日期直接相关的类有很多,平时最常用到的就是java.util package下面的Date和Calendar,需要用到格式的时候还会用到java.text.SimpleDateFormat 首先吐槽一下,Date和Calendar实际用起来还是有一些别扭的,刚开始用的时候不熟悉,老是分不清Date和Calendar类的具体用法和区别. 而且Calendar类的set方法来设置日期时又有一些反人类,设置月份的时候总是要脑补一下减去1,比如要设置为2018年1月6日就要设置成2018,0

  • Java统计英文句子中出现次数最多的单词并计算出现次数的方法

    本文实例讲述了Java统计英文句子中出现次数最多的单词并计算出现次数的方法.分享给大家供大家参考,具体如下: import java.util.*; /** * 统计出现次数最多的单词和它出现的次数 * * @author ZHR */ public class CountWord { public static String[] strTostrArray(String str) { /* * 将非字母字符全部替换为空格字符" " 得到一个全小写的纯字母字符串包含有空格字符 */ s

  • Java计算文本MD5加密值的方法示例

    本文实例讲述了Java计算文本MD5加密值的方法.分享给大家供大家参考,具体如下: java计算文本MD5值,用于加密 import java.security.MessageDigest; import java.security.NoSuchAlgorithmException; public class GetMd5 { public static void main(String[] args) { String a="123"; System.out.println(getM

随机推荐