Daily question 5-1636 Sort arrays in ascending order by frequency

subject ：

Give you an array of integers  nums , Please arrange the array according to the frequency of each value Ascending Sort . If there are multiple values with the same frequency , Please put them according to the value itself Descending Sort .

Please return the sorted array .

Example 1：

Input ：nums = [1,1,2,2,2,3]
Output ：[3,1,1,2,2,2]
explain ：‘3’ The frequency is 1,‘1’ The frequency is 2,‘2’ The frequency is 3 .
Example 2：

Input ：nums = [2,3,1,3,2]
Output ：[1,3,3,2,2]
explain ：‘2’ and ‘3’ The frequencies are 2 , So they are sorted in descending order according to the value itself .
Example 3：

Input ：nums = [-1,1,-6,4,5,-6,1,4,1]
Output ：[5,-1,4,4,-6,-6,1,1,1]

Tips ：

1 <= nums.length <= 100
-100 <= nums[i] <= 100

Ideas ：

Define a class first , Record the element value and frequency of each element , Use a list to store all the two tuples , And sort the list .

• If the frequencies of two tuples are different , Sort by frequency in ascending order ;

• If two tuples have the same frequency , Sort by element value in descending order .

Traverse the sorted list , For each binary in the list , Fill the element values into the sorted array according to the frequency . After traversal, you can get the complete sorted array .

java Code ：

class Solution {
    class Pair {
        int num;
        int freq;

        public Pair(int num, int freq) {
            this.num = num;
            this.freq = freq;
        }
    }

    public int[] frequencySort(int[] nums) {
            Map<Integer, Integer> map = new HashMap<>();
            for (int n : nums) {
                map.put(n, map.getOrDefault(n, 0) + 1);
            }

            List<Pair> pairs = new ArrayList<>();
            for (Map.Entry<Integer, Integer> entry : map.entrySet()) {
                pairs.add(new Pair(entry.getKey(), entry.getValue()));
            }

            Collections.sort(pairs, (a, b) -> {
                if (a.freq != b.freq) {
                    return a.freq - b.freq;
                } else {
                    return b.num - a.num;
                }
            });
            
            int[] sorted = new int[nums.length];
            int index = 0;
            for(Pair pair:pairs) {
                int num = pair.num;
                for(int i=0;i<pair.freq;i++) {
                    sorted[index++] = num;
                }
            }

            return sorted;
        }
}