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 计算中位数的实现方法就是小编分享给大家的全部内容了，希望能给大家一个参考，也希望大家多多支持。