1.众数问题：

给定含有N个元素的多重集合S，每个元素在S中出现的次数称为该元素的重数，多重集合S中重数最大的元素称为多重集合S的众数，众数的重数称为多重集合S的重数，试求一个给定多重结合的重数和众数。

例如：S={a,b,b,b,f,f,4,5}的重数是3，众数是b

2.算法思路：

• 首先为集合S排序，使之成为有序的数组（使用Arrays类的sort方法）
• 取中位数为众数，中位数的个数为重数，确定左右界
• 向左界递归，取中位数为众数，取中位数个数为重数，比较
• 向右界递归，取中位数为众数，取中位数个数为重数，比较

3.问题：

翻阅网上的代码，多是使用c++实现，而c++代码中有引用参数传递的过程，在程序运行中可以直接引用函数传参，但Java中没有提供。在阅读(7条消息) 分治法-众数问题java实现_cook_1996的博客-CSDN博客 这篇博客后，发现了IntHolder这个类。

IntHolder持有者类型：因为java中只存在值传递，同时包装类一旦创建其数值是不能改变的。所有不可能实现一个方法改变一个数据类型的值。如果想编写一个修改数据值参数的方法，就需要使用在 org.omg.CORBA 包中定义的持有者（holder）类型，包括IntHolder、BooleanHolder等。每个持有者类型都包含一个共有域值，通过它可以访问储存在其中的值。

4.代码：

import jdk.nashorn.internal.runtime.regexp.joni.encoding.IntHolder;

import java.lang.reflect.Array;
import java.util.Arrays;
import java.util.Scanner;

public class Mode {

    public static void getMaxCnt(int a[], int n, IntHolder num, IntHolder maxCnt){
        int l =0, r = 0;
        int s;
        int mid = n / 2;
        for( l = 0;l < mid;l ++){
            if(a[l] == a[mid])
                break;
        }
        for(r = mid + 1;r < n;r ++){
            if(a[r] != a[mid])
                break;
        }
        s = r - l;
        if(s > maxCnt.value){
            num.value = a[mid];
            maxCnt.value = s;
        }
        if(s == maxCnt.value){
            if(num.value > a[mid]){
                num.value = a[mid];
                maxCnt.value = s;
            }
        }
        if(l + 1 > maxCnt.value){
            getMaxCnt(a,l+1,num,maxCnt);
        }
        if(n - r > maxCnt.value){
            int [] b = new int[n-r];
            for(int i = 0;i < n-r;i ++){
                b[i] = a[r + i];
            }
            getMaxCnt(b,n-r,num,maxCnt);
        }

    }

    public static void main(String[] args) {
        int i,n;

        IntHolder num = new IntHolder();
         IntHolder maxCnt = new IntHolder();
        System.out.println("请输入数组个数：");
        Scanner scanner = new Scanner(System.in);
        n = scanner.nextInt();
        int []a = new int[n];
        System.out.println("请输入一个数组：");
        for(i = 0;i < n;i ++){
            a[i] = scanner.nextInt();
        }
        Arrays.sort(a);
        getMaxCnt(a,n,num,maxCnt);
        System.out.println("众数：" + num.value + " 重数：" + maxCnt.value);
    }
}

众数问题

问题描述：
给定含有n个元素的多重集合s,每个元素在S中出现的次数称为该元素的重数。多重集S中重数最大的元素称为众数。例如， S-(1, 2, 2, 2, 3, 3, 5).多重集S的众数是2,其重数为3,对于给定的由n个自然数组成的多重集s,计算S的众数及其重数。如果出现多个众数，请输出最小的那个。
输入数据的第1行是多重集S中元素个数n (n<1 300000) ;接下来的n行中，每行有一个最多含有5位数字的自然数。输出数据的第1行给出众数，第2行是重数。
样例为：
Sample input
6
1
2
2
2
3
5
Sample output
2
3
算法思想：

取中位数的个数为重数，中位数为众数，确定左界、右界。

在往左界递归取中位数为众数，个数为重数，比较

往右界递归取中位数为众数，个数为重数，比较

注意！！！

如果中位数的个数大于左界个数，那左边一定没有该组数据的众数；反之，右边一样。

该程序要求数据有序（从小到大），本程序未写排序算法。
————————————————

import java.io.*;
public class que {
    public static int chong = 0, zhong = 0;

    public static void main(String[] args) {
        FileReader fr = null;
        BufferedReader br = null;
        FileReader fr2 = null;
        BufferedReader br2 = null;
        FileWriter fw = null;
        BufferedWriter bw = null;
        try {
            fr = new FileReader("src//1.txt");
            br = new BufferedReader(fr);
            fw = new FileWriter("src//2.txt");
            bw = new BufferedWriter(fw);
        } catch (IOException e) {
            System.out.println("error1");
        }
        int i = 0, count = 0;
        String s;
        try {// 计算有多少个数
            while ((s = br.readLine()) != null) {
                count++;
            }
            br.close();
        } catch (Exception e) {
            System.out.println("error2");
        }
        int[] arr = new int[count];
        try//读取n个数
        {
            fr2 = new FileReader("src//1.txt");
            br2 = new BufferedReader(fr2);
            while ((s = br2.readLine()) != null) {
                arr[i] = Integer.parseInt(s);
                i++;
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        sort(arr);

        zhongshu(arr, 0, arr.length - 1);
        try {
            bw.write(zhong + "");
            bw.newLine();
            bw.write(chong + "");
            bw.close();
        } catch (IOException e) {
            e.printStackTrace();
        }

    }

    public static void zhongshu(int arr[], int l, int r) {
        int m, c1 = 0, c2 = 0, i, j, val;
        m = (r + l) / 2;
        i = m;
        j = m;
        val = arr[m];
        while (i >= l && arr[i] == val) {
            i--;
            c1++;
        }

        while (j <= r && arr[j] == val) {
            j++;
            c2++;
        }
        if (chong < j - i - 1) {
            chong = j - i - 1;
            zhong = val;
        }
        if (i - l + 1 > chong)
            zhongshu(arr, l, i);
        if (r - j + 1 > chong)
            zhongshu(arr, j, r);
    }


    public static void sort(int[] arr) {
        for (int i = 0; i < arr.length - 1; i++) {
            int min = i; // 遍历的区间最小的值
            for (int j = i + 1; j < arr.length; j++) {
                if (arr[j] < arr[min]) {
                    // 找到当前遍历区间最小的值的索引
                    min = j;
                }
            }
            if (min != i) {
                // 发生了调换
                int temp = arr[min];
                arr[min] = arr[i];
                arr[i] = temp;
            }
        }
    }


}

题目描述：
问题描述：
给定含有n个元素的多重集合S，每个元素在S中出现的次数称为该元素的重数。多重集S中重数最大的元素称为众数。
例如，S={1，2，2，2，3，5}。多重集S的众数是2，其重数为3。
编程任务：
对于给定的由n 个自然数组成的多重集S，编程计算S 的众数及其重数。

输入：
第1行多重集S中元素个数n(n<=50000)；接下来的n 行中，每行有一个自然数。

输出：
输出文件有2 行，第1 行给出众数，第2 行是重数。(如果有多个众数，只输出最小的)

样例输入：
6
1
2
2
2
3
5

样例输出：
2
3

全部代码：

import java.util.Scanner;

public class Main {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int n = sc.nextInt();
		int []s = new int[n];
		int []k = new int[50000];
		for(int i=0; i<n; i++)
		{
		    s[i]=sc.nextInt();
		    
		}
		for(int i=0; i<k.length; i++)
		{
		    k[i]=0;
		}
		for(int i=0; i<n; i++)
		{
		    for(int j=0; j<k.length; j++)
		    {
		        if(s[i]==j)
		        {
		            k[j]++;
		        }
		    }
		}
		int temp=0,x=0;
		for(int i=0; i<k.length; i++)
		{
		    if(k[i]>temp)
		    {
		        temp=k[i];
		        x=i;
		    }
		}
		System.out.println(x);
		System.out.println(temp);
	}
}