leetcode题解-451. Sort Characters By Frequency

题目：Given a string, sort it in decreasing order based on the frequency of characters.
Example 1: Input: “tree” Output: “eert”
Explanation: ‘e’ appears twice while ‘r’ and ‘t’ both appear once. So ‘e’ must appear before both ‘r’ and ‘t’. Therefore “eetr” is also a valid answer.
Example 2: Input: “cccaaa” Output: “cccaaa”
Explanation: Both ‘c’ and ‘a’ appear three times, so “aaaccc” is also a valid answer. Note that “cacaca” is incorrect, as the same characters must be together.
Example 3: Input: “Aabb” Output: “bbAa”
Explanation: “bbaA” is also a valid answer, but “Aabb” is incorrect. Note that ‘A’ and ‘a’ are treated as two different characters.
有题目知，本题目的是按照字符串出现次数多少进行排序并返回新的数组。其中次数相同的字符次序不作要求，大小写算不同的字符处理。本题乍一看很简单，对字符串进行遍历计数似乎就解决了，但是仔细一想，字符和其出现次数的对应关系该用什么数据结构进行记录呢，特别是要对次数进行排序，排序之后二者关系又该如何对应。这都是我们要考虑的问题。
首先可能会想到使用map来保存字符和其出现次数的对应关系，然后再用一个数组（其索引是出现次数而值是相应的字符或者字符串（如果多个字符出现次数相同））来排序，在之后反向遍历该数组生成最终的字符串。代码入下，击败了33%的用户：

    public String frequencySort(String s) {
        if (s == null) {
            return null;
        }
        Map<Character, Integer> map = new HashMap();
        char[] charArray = s.toCharArray();
        int max = 0;
        for (Character c : charArray) {
            if (!map.containsKey(c)) {
                map.put(c, 0);
            }
            map.put(c, map.get(c) + 1);
            max = Math.max(max, map.get(c));
        }

        List<Character>[] array = buildArray(map, max);

        return buildString(array);
    }

    private List<Character>[] buildArray(Map<Character, Integer> map, int maxCount) {
        List<Character>[] array = new List[maxCount + 1];
        for (Character c : map.keySet()) {
            int count = map.get(c);
            if (array[count] == null) {
                array[count] = new ArrayList();
            }
            array[count].add(c);
        }
        return array;
    }

    private String buildString(List<Character>[] array) {
        StringBuilder sb = new StringBuilder();
        for (int i = array.length - 1; i > 0; i--) {
            List<Character> list = array[i];
            if (list != null) {
                for (Character c : list) {
                    for (int j = 0; j < i; j++) {
                        sb.append(c);
                    }
                }
            }
        }
        return sb.toString();
    }

想想该怎么改进呢，我们之前的题目中也经常使用数组（索引是次数、字符等信息）来代替map保存我们想要的信息，所以这里也可以使用这种方法进行改进，这种方法击败了93%的用户，代码入下。

    public String frequencySort1(String s){
        if(s.length()<3)
            return s;
        int [] map = new int [256];
        int max = 0;
        for(Character c:s.toCharArray()){
            map[c] ++;
            max = Math.max(max, map[c]);
        }
        String[] buckets = new String[max + 1];
        for(int i=0; i<256; i++){
            String str = buckets[map[i]];
            if(map[i] > 0)
                buckets[map[i]] = (str == null)? "" + (char)i : (str + (char)i);
        }
        StringBuilder strb = new StringBuilder();
        for(int i=max; i>=0; i--){
            if(buckets[i] != null)
                for(char c:buckets[i].toCharArray())
                    for(int j=0; j<i; j++)
                        strb.append(c);
        }
        return strb.toString();
    }

此外，我还看到一种使用map保存排序信息的方法，这种方法思想和上面两种方法是一样的，击败了78%的用户，代码入下：

public String frequencySort2(String s) {
        char[] arr = s.toCharArray();

        // bucket sort
        int[] count = new int[256];
        for(char c : arr) count[c]++;

        // count values and their corresponding letters
        Map<Integer, List<Character>> map = new HashMap<>();
        for(int i = 0; i < 256; i++){
            if(count[i] == 0) continue;
            int cnt = count[i];
            if(!map.containsKey(cnt)){
                map.put(cnt, new ArrayList<Character>());
            }
            map.get(cnt).add((char)i);
        }

        // loop throught possible count values
        StringBuilder sb = new StringBuilder();
        for(int cnt = arr.length; cnt > 0; cnt--){ 
            if(!map.containsKey(cnt)) continue;
            List<Character> list = map.get(cnt);
            for(Character c: list){
                for(int i = 0; i < cnt; i++){
                    sb.append(c);
                }
            }
        }
        return sb.toString();
    }