找水王

这个问题是这样的:

　　对于一个特别喜欢在论坛评论的人,他的评论的帖子数是最多的.

　　好,下面先看代码

import java.util.Random;

public class Find {
    public static final String NUMBERCHAR = "12345959";

    public static void main(String[] args) {
        Random random = new Random();
        int a[] = new int[2000];
        for (int i = 0; i < a.length; i++) {
            a[i] = random.nextInt(NUMBERCHAR.length());
        }

        int sum = 0, count = 0, result = 0;
        for (int i = 0; i < a.length; i++) {
            for (int j = i; j < a.length - i; j++) {
                if (a[i] == a[j]) {
                    count++;
                }
            }
            if (count > sum) {
                result = a[i];
                sum = count;
            }
            count = 0;
        }
        
        System.out.println("水王最可能是:" + result);
        System.out.println("出现的次数为:" + sum);
    }
}

也可以先将重复的值去掉,然后重新进行排序

        // 去掉重复
        Set<Object> set = new HashSet<Object>();
        for (Object o : a) {
            set.add(o);
        }

        //将得到的数组放到新的数组中
        Object[] b = set.toArray();        

这是比较简单的方法,通过产生随机数储存到数组,来对数组中各元素进行比较统计,然后将统计出的结果进行输出.但是这样的时间复杂度是O(n^2),那么,有没有更加简单的方法来解决这个问题呢?

我们知道,在java.util 中包含我们最常用的集合类,最常用的就是List和Map.那么,在Map中,我们通过使用他的储存映射,可不可以解决这个问题呢?

　　Map中提供HashMap来通过键的值储存数据排序,并可通过put函数进行插入或者统计;而在进行遍历时,可以通过增强for循环遍历,使用entrySet()进行遍历.那么,我们怎么来使用他们来解决我们上述问题呢?

请看代码:

import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.Map;
import java.util.Random;

public class Find_3 {

    public static final String NUMBERCHAR = "123456789";

    public static void main(String[] args) {

        Random random = new Random();
        int a[] = new int[2000];
        for (int i = 0; i < a.length; i++) {
            int num = random.nextInt(NUMBERCHAR.length());
            // String c = new DecimalFormat("000").format(num);//产生随机数,在前面补0,返回类型为String
            // a[i]= Integer.parseInt(c);
            a[i] = num;
            // System.out.println(a[i]);

        }

        HashMap<Integer, Integer> map = new HashMap<Integer, Integer>();
        for (int i = 0; i < a.length; i++) {
            if (map.containsKey(a[i])) {//通过值来统计数组的相同元素的个数
                int sum = map.get(a[i]);
                map.put(a[i], sum + 1);
            } else {
                map.put(a[i], 1);
            }
        }

        Collection<Integer> count = map.values();
        int mcount = Collections.max(count);
        int number = 0;

        for (Map.Entry<Integer, Integer> entry : map.entrySet()) {//将最后的元素进行遍历取出

            if (mcount == entry.getValue()) {
                number = entry.getKey();
            }
        }
        System.out.println("出现次数最多的数字为:" + number);
        System.out.println("一共出现" + mcount + "次");

    }
}

好,这样就解决了一个问题.

截图：

 

 总结：

这又让我想起了我们以前做的一个关于一维数组的最大子数组的问题,当时我们也提到过时间复杂度的问题,那么,从这个问题中,我们是否也可以找到一个求解这种问题的方法呢?