栈与队列-前 K 个高频元素

题目

思路-转list，用sort方法

1. 统计出现频率，在之前哈希表也有用到过，使用map来完成。

2. 将map转换为list。使用map的遍历方式-entryset。(泛型的时候注意，是Map.Entry<Integer, Integer>)。下面为介绍：
   map集合的entrySet方法可以获取一个Set集合，集合中存放的是Entry对象，一个Entry对象相当于一个键值对。我们可以遍历set集合拿到Entry对象，然后获取出里面的键和值。

Set<Map.Entry<String, String>> entries = map.entrySet();
//可以使用迭代器或者foreach方式来完成遍历
 for (Map.Entry<String, String> entry : entries) {
	System.out.println(entry.getKey()+"===="+entry.getValue());
}

Iterator<Map.Entry<String, String>> it = entries.iterator();
while (it.hasNext()){
	Map.Entry<String, String> entry = it.next();
	System.out.println(entry.getKey()+"===="+entry.getValue());
}

同时map还有个keySet方法可以获取一个Set集合，集合中存放的是所有的key。我们可以遍历set集合拿到key对象，然后通过key获取对应的value。

3. Java中Collections.sort()的使用，将map中的value按照降序排列。下面为介绍：
   在日常开发中，很多时候都需要对一些数据进行排序的操作。然而那些数据一般都是放在一个集合中如：Map ，Set ，List 等集合中。他们都提供了一个排序方法 sort()，要对数据排序直接使用这个方法就行，但是要保证集合中的对象是可比较的。如何实现按照我们想要的规则比较。我们需要该对象实现 Comparable 接口。然后重写里面的compareTo()方法。我们可以看到Java中很多类都是实现类这个接口的。Collections.sort(list,Comparator）

4. 把list的key放入result数组（即结果）

new ArrayList<>()时可以传入的参数类型为：
1、int整型。规定arraylist的初始长度。
2、构造一个包含指定Collection的元素的集合，这些元素时按照collection的迭代器返回他们的顺序排列的。

下面为代码实现（显示结果）：

    public static void topKFrequent(int[] nums, int k) {
        //统计元素出现的频率
        Map<Integer,Integer> map = new HashMap<>();
        //收集结果,统计前k高-长度
        int[] result = new int[k];
        for (int num:nums) {
            if (map.containsKey(num)){
                map.put(num,map.get(num)+1);
            }else{
                map.put(num,1);
            }
        }
        //按照map的value来进行排序
        //自定义比较器
        Comparator<Map.Entry<Integer, Integer>> valCmp = new Comparator<Map.Entry<Integer,Integer>>() {
            @Override
            public int compare(Map.Entry<Integer, Integer> o1, Map.Entry<Integer, Integer> o2) {
                // TODO Auto-generated method stub
                return o2.getValue()-o1.getValue();  // 降序排序，如果想升序就反过来
            }
        };
        //将map转成List，map的一组key，value对应list一个存储空间
        List<Map.Entry<Integer, Integer>> list = new ArrayList<Map.Entry<Integer,Integer>>(map.entrySet()); //传入map实体
        Collections.sort(list,valCmp);
        // 注意此处Collections 是java.util包下面的,传入List和自定义的valCmp比较器
        //输出map
        for(int i=0;i<list.size();i++) {
            System.out.println(list.get(i).getKey() + " = " + list.get(i).getValue());
        }
    }

最终把他放入result里面。下面为完整代码：

    public int[] topKFrequent(int[] nums, int k) {
        //统计元素出现的频率
        Map<Integer,Integer> map = new HashMap<>();
        //收集结果,统计前k高-长度
        int[] result = new int[k];
        for (int num:nums) {
            if (map.containsKey(num)){
                map.put(num,map.get(num)+1);
            }else{
                map.put(num,1);
            }
        }
        //按照map的value来进行排序
        //自定义比较器
        Comparator<Map.Entry<Integer, Integer>> valCmp = new Comparator<Map.Entry<Integer,Integer>>() {
            @Override
            public int compare(Map.Entry<Integer, Integer> o1, Map.Entry<Integer, Integer> o2) {
                // TODO Auto-generated method stub
                return o2.getValue()-o1.getValue();  // 降序排序，如果想升序就反过来
            }
        };
        //将map转成List，map的一组key，value对应list一个存储空间
        List<Map.Entry<Integer, Integer>> list = new ArrayList<Map.Entry<Integer,Integer>>(map.entrySet()); //传入map实体
        Collections.sort(list,valCmp);
        // 注意此处Collections 是java.util包下面的,传入List和自定义的valCmp比较器
        for (int i = 0; i < k; i++) {
            result[i] = list.get(i).getKey();
        }
        return result;
    }

思路-优先队列

优先队列：
https://www.cnblogs.com/Elliott-Su-Faith-change-our-life/p/7472265.html

或者直接看java手册的使用
https://www.matools.com/api/java8
下面对使用的方罗列一下：

1. PriorityQueue(Comparator<? super E> comparator)
   创建具有默认初始容量的 PriorityQueue ，并根据指定的比较器对其元素进行排序。
2. offer(E e)
   将指定的元素插入到此优先级队列中。
3. poll()
   检索并删除此队列的头，如果此队列为空，则返回 null 。
4. size()
   返回此集合中的元素数。
5. Map.Entry类提供了一个getKey()方法和一个getValue()方法，所以我们可以直接拿到key。

public int[] topKFrequent(int[] nums, int k) {
         int[] result = new int[k];
        HashMap<Integer, Integer> map = new HashMap<>();
        for (int num : nums) {
            //getOrDefault() 方法获取指定 key 对应对 value，如果找不到 key ，则返回设置的默认值。
            //更为简单的实现了对频率的统计
            map.put(num, map.getOrDefault(num, 0) + 1);
        }
        Set<Map.Entry<Integer, Integer>> entries = map.entrySet();
        //建造优先队列
        //自定义比较器
        Comparator<Map.Entry<Integer, Integer>> valCmp = new Comparator<Map.Entry<Integer,Integer>>() {
            @Override
            public int compare(Map.Entry<Integer, Integer> o1, Map.Entry<Integer, Integer> o2) {
                // TODO Auto-generated method stub
                return o1.getValue()-o2.getValue();  // 升序
            }
        };
        PriorityQueue<Map.Entry<Integer, Integer>> queue = new PriorityQueue<>(valCmp);
        for (Map.Entry<Integer, Integer> entry : entries) {
            queue.offer(entry);
            if (queue.size() > k) {
                queue.poll();
            }
        }
        for (int i = k - 1; i >= 0; i--) {
            result[i] = queue.poll().getKey();
        }
        return result;
    }

也可以把比较器放在里面

        Set<Map.Entry<Integer, Integer>> entries = map.entrySet();
        //建造优先队列
        PriorityQueue<Map.Entry<Integer, Integer>> queue = new PriorityQueue<>(new Comparator<Map.Entry<Integer, Integer>>(){ 
            @Override
            public int compare(Map.Entry<Integer, Integer> o1, Map.Entry<Integer, Integer> o2) {
                // TODO Auto-generated method stub
                return o1.getValue()-o2.getValue(); 
                }
        });