c语言sscanf函数的用法是什么
235
2023-03-26
java 计算中位数的实现方法
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
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
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
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
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 while(left right--; } if(left nums[left]=nums[right]; left++; } while(left left++; } if(left 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 while(left right--; } if(left nums[left]=nums[right]; left++; } while(left left++; } if(left nums[right]=nums[left]; right--; } } nums[left]=pivot; return left; } /** * 众数(int) * 众数:在一个数组中出现次数最多的数 * 如果存在多个众数，则一起返回 * @param arr * @return */ public static List int n = arr.length; if (n == 0) { return new ArrayList } if (n == 1) { return Arrays.asList(arr[0]); } Map 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 // 对 entries 按出现频率从大到小排序 Collections.sort(entries, new Comparator @Override public int compare(Map.Entry return e2.getValue() - e1.getValue(); } }); List 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 int n = arr.length; if (n == 0) { return new ArrayList } if (n == 1) { return Arrays.asList(arr[0]); } Map 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 // 对 entries 按出现频率从大到小排序 Collections.sort(entries, new Comparator @Override public int compare(Map.Entry return e2.getValue() - e1.getValue(); } }); List 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; } }
while(left
right--;
}
if(left nums[left]=nums[right]; left++; } while(left left++; } if(left 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 while(left right--; } if(left nums[left]=nums[right]; left++; } while(left left++; } if(left nums[right]=nums[left]; right--; } } nums[left]=pivot; return left; } /** * 众数(int) * 众数:在一个数组中出现次数最多的数 * 如果存在多个众数，则一起返回 * @param arr * @return */ public static List int n = arr.length; if (n == 0) { return new ArrayList } if (n == 1) { return Arrays.asList(arr[0]); } Map 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 // 对 entries 按出现频率从大到小排序 Collections.sort(entries, new Comparator @Override public int compare(Map.Entry return e2.getValue() - e1.getValue(); } }); List 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 int n = arr.length; if (n == 0) { return new ArrayList } if (n == 1) { return Arrays.asList(arr[0]); } Map 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 // 对 entries 按出现频率从大到小排序 Collections.sort(entries, new Comparator @Override public int compare(Map.Entry return e2.getValue() - e1.getValue(); } }); List 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; } }
nums[left]=nums[right];
left++;
}
while(left left++; } if(left 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 while(left right--; } if(left nums[left]=nums[right]; left++; } while(left left++; } if(left nums[right]=nums[left]; right--; } } nums[left]=pivot; return left; } /** * 众数(int) * 众数:在一个数组中出现次数最多的数 * 如果存在多个众数，则一起返回 * @param arr * @return */ public static List int n = arr.length; if (n == 0) { return new ArrayList } if (n == 1) { return Arrays.asList(arr[0]); } Map 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 // 对 entries 按出现频率从大到小排序 Collections.sort(entries, new Comparator @Override public int compare(Map.Entry return e2.getValue() - e1.getValue(); } }); List 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 int n = arr.length; if (n == 0) { return new ArrayList } if (n == 1) { return Arrays.asList(arr[0]); } Map 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 // 对 entries 按出现频率从大到小排序 Collections.sort(entries, new Comparator @Override public int compare(Map.Entry return e2.getValue() - e1.getValue(); } }); List 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; } }
left++;
}
if(left 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 while(left right--; } if(left nums[left]=nums[right]; left++; } while(left left++; } if(left nums[right]=nums[left]; right--; } } nums[left]=pivot; return left; } /** * 众数(int) * 众数:在一个数组中出现次数最多的数 * 如果存在多个众数，则一起返回 * @param arr * @return */ public static List int n = arr.length; if (n == 0) { return new ArrayList } if (n == 1) { return Arrays.asList(arr[0]); } Map 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 // 对 entries 按出现频率从大到小排序 Collections.sort(entries, new Comparator @Override public int compare(Map.Entry return e2.getValue() - e1.getValue(); } }); List 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 int n = arr.length; if (n == 0) { return new ArrayList } if (n == 1) { return Arrays.asList(arr[0]); } Map 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 // 对 entries 按出现频率从大到小排序 Collections.sort(entries, new Comparator @Override public int compare(Map.Entry return e2.getValue() - e1.getValue(); } }); List 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; } }
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 while(left right--; } if(left nums[left]=nums[right]; left++; } while(left left++; } if(left nums[right]=nums[left]; right--; } } nums[left]=pivot; return left; } /** * 众数(int) * 众数:在一个数组中出现次数最多的数 * 如果存在多个众数，则一起返回 * @param arr * @return */ public static List int n = arr.length; if (n == 0) { return new ArrayList } if (n == 1) { return Arrays.asList(arr[0]); } Map 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 // 对 entries 按出现频率从大到小排序 Collections.sort(entries, new Comparator @Override public int compare(Map.Entry return e2.getValue() - e1.getValue(); } }); List 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 int n = arr.length; if (n == 0) { return new ArrayList } if (n == 1) { return Arrays.asList(arr[0]); } Map 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 // 对 entries 按出现频率从大到小排序 Collections.sort(entries, new Comparator @Override public int compare(Map.Entry return e2.getValue() - e1.getValue(); } }); List 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; } }
while(left
right--;
}
if(left nums[left]=nums[right]; left++; } while(left left++; } if(left nums[right]=nums[left]; right--; } } nums[left]=pivot; return left; } /** * 众数(int) * 众数:在一个数组中出现次数最多的数 * 如果存在多个众数，则一起返回 * @param arr * @return */ public static List int n = arr.length; if (n == 0) { return new ArrayList } if (n == 1) { return Arrays.asList(arr[0]); } Map 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 // 对 entries 按出现频率从大到小排序 Collections.sort(entries, new Comparator @Override public int compare(Map.Entry return e2.getValue() - e1.getValue(); } }); List 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 int n = arr.length; if (n == 0) { return new ArrayList } if (n == 1) { return Arrays.asList(arr[0]); } Map 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 // 对 entries 按出现频率从大到小排序 Collections.sort(entries, new Comparator @Override public int compare(Map.Entry return e2.getValue() - e1.getValue(); } }); List 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; } }
nums[left]=nums[right];
left++;
}
while(left left++; } if(left nums[right]=nums[left]; right--; } } nums[left]=pivot; return left; } /** * 众数(int) * 众数:在一个数组中出现次数最多的数 * 如果存在多个众数，则一起返回 * @param arr * @return */ public static List int n = arr.length; if (n == 0) { return new ArrayList } if (n == 1) { return Arrays.asList(arr[0]); } Map 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 // 对 entries 按出现频率从大到小排序 Collections.sort(entries, new Comparator @Override public int compare(Map.Entry return e2.getValue() - e1.getValue(); } }); List 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 int n = arr.length; if (n == 0) { return new ArrayList } if (n == 1) { return Arrays.asList(arr[0]); } Map 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 // 对 entries 按出现频率从大到小排序 Collections.sort(entries, new Comparator @Override public int compare(Map.Entry return e2.getValue() - e1.getValue(); } }); List 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; } }
left++;
}
if(left nums[right]=nums[left]; right--; } } nums[left]=pivot; return left; } /** * 众数(int) * 众数:在一个数组中出现次数最多的数 * 如果存在多个众数，则一起返回 * @param arr * @return */ public static List int n = arr.length; if (n == 0) { return new ArrayList } if (n == 1) { return Arrays.asList(arr[0]); } Map 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 // 对 entries 按出现频率从大到小排序 Collections.sort(entries, new Comparator @Override public int compare(Map.Entry return e2.getValue() - e1.getValue(); } }); List 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 int n = arr.length; if (n == 0) { return new ArrayList } if (n == 1) { return Arrays.asList(arr[0]); } Map 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 // 对 entries 按出现频率从大到小排序 Collections.sort(entries, new Comparator @Override public int compare(Map.Entry return e2.getValue() - e1.getValue(); } }); List 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; } }
nums[right]=nums[left];
right--;
}
}
nums[left]=pivot;
return left;
}
/**
* 众数(int)
* 众数:在一个数组中出现次数最多的数
* 如果存在多个众数，则一起返回
* @param arr
* @return
*/
public static List
int n = arr.length;
if (n == 0) {
return new ArrayList
}
if (n == 1) {
return Arrays.asList(arr[0]);
}
Map
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
// 对 entries 按出现频率从大到小排序
Collections.sort(entries, new Comparator
@Override
public int compare(Map.Entry
return e2.getValue() - e1.getValue();
}
});
List
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
int n = arr.length;
if (n == 0) {
return new ArrayList
}
if (n == 1) {
return Arrays.asList(arr[0]);
}
Map
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
// 对 entries 按出现频率从大到小排序
Collections.sort(entries, new Comparator
@Override
public int compare(Map.Entry
return e2.getValue() - e1.getValue();
}
});
List
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;
}
}
版权声明：本文内容由网络用户投稿，版权归原作者所有，本站不拥有其著作权，亦不承担相应法律责任。如果您发现本站中有涉嫌抄袭或描述失实的内容，请联系我们jiasou666@gmail.com 处理，核实后本网站将在24小时内删除侵权内容。
相关文章
发表评论
暂时没有评论，来抢沙发吧~