Leetcode: 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.

Bucket Sort + HashMap

 public class Solution {
     public String frequencySort(String s) {
         Map<Character, Integer> map = new HashMap<>();
         for (char c : s.toCharArray()) {
             if (map.containsKey(c)) {
                 map.put(c, map.get(c) + 1);
             } else {
                 map.put(c, 1);
             }
         }
         List<Character> [] bucket = new List[s.length() + 1];
         for (char key : map.keySet()) {
             int frequency = map.get(key);
             if (bucket[frequency] == null) {
                 bucket[frequency] = new ArrayList<>();
             }
             bucket[frequency].add(key);
         }
         StringBuilder sb = new StringBuilder();
         for (int pos = bucket.length - 1; pos >=0; pos--) {
             if (bucket[pos] != null) {
                 for (char num : bucket[pos]) {
                     for (int i = 0; i < map.get(num); i++) {
                         sb.append(num);
                     }
                 }
             }
         }
         return sb.toString();
     }
 }

HashMap+ Heap+Wrapper Class

 public class Solution {
     public String frequencySort(String s) {
         PriorityQueue<WrapperChar> maxheap = new PriorityQueue(1, new Comparator<WrapperChar>() {
             public int compare(WrapperChar w1, WrapperChar w2) {
                 return w2.count - w1.count;
             }
         });
         HashMap<Character, WrapperChar> map = new HashMap<Character, WrapperChar>();
         for (int i=0; i<s.length(); i++) {
             char c = s.charAt(i);
             if (!map.containsKey(c)) map.put(c, new WrapperChar(c, 1));
             else {
                 int newCount = map.get(c).count + 1;
                 map.put(c, new WrapperChar(c, newCount));
             }
         }
         for (char c : map.keySet()) maxheap.offer(map.get(c));
         StringBuilder res = new StringBuilder();
         while (!maxheap.isEmpty()) {
             WrapperChar wChar = maxheap.poll();
             for (int i=0; i<wChar.count; i++) {
                 res.append(wChar.c);
             }
         }
         return res.toString();
     }

     public class WrapperChar {
         char c;
         int count;
         public WrapperChar(char ch, int num) {
             this.c = ch;
             this.count = num;
         }
     }
 }