最新一道面試題目，input: int[1,1,2,2,2,3,3,3]，output [3,2,1]，要求按照數字出現的次數從多到少排列元素。

面試當時沒有及時答出來，感覺當時在面試官的提示下跑偏了。想用兩個數組來mapping key和value然後對等排序，但是因為面試官讓用Array.sort而沒想好有什麼好辦法，結果可想而知。但是題目還是要做的，所以，先研究一下這個題目。發現中文搜索沒有找到對應的題目，leetcode上面也沒找到，用英文的找到了怎麼給HashMap按照key和value分別排序的解法。先這樣解決一下。如果誰有更好的解法，歡迎分享。

今天學習到了Java8裡面的簡單寫法，先貼這裡，回家debug一下。

        Map<String, Integer> result2 = new LinkedHashMap<>();
        map.entrySet().stream()
                .sorted(Map.Entry.<String, Integer>comparingByValue().reversed())
                .forEachOrdered(x -> result2.put(x.getKey(), x.getValue()));

把第一種解法這樣改就可以了：

    public static int[] countSort(int[] nums){
        if(nums == null || nums.length ==0)
        return null;
        Map<Integer, Integer> map = new HashMap<Integer, Integer>();

        for(int i = 0; i < nums.length; i++){
        if(map.containsKey(nums[i]))
            map.put(nums[i], map.get(nums[i]) + 1);
        else
            map.put(nums[i], 1);
        }

        Map<Integer, Integer> resultMap = new LinkedHashMap<>(); 
　　　　 map.entrySet().stream() 
　　　　　　.sorted(Map.Entry.<Integer, Integer>comparingByValue().reversed())
　　　　　　.forEachOrdered(x -> resultMap.put(x.getKey(), x.getValue()));

　　　　int[] result = new int[resultMap.size()]; 
　　　　int i = 0; 
　　　　for(Map.Entry<Integer, Integer> entry : resultMap.entrySet()){
　　　　 　　result[i++] = entry.getKey(); 
　　　　} 
　　　　return result; 
　　}

package ArraySort;

import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;

public class ArraySort {
    public static int[] countSort(int[] nums){
        if(nums == null || nums.length ==0)
        return null;
        HashMap<Integer, Integer> map = new HashMap<Integer, Integer>();

        for(int i = 0; i < nums.length; i++){
        if(map.containsKey(nums[i]))
            map.put(nums[i], map.get(nums[i]) + 1);
        else
            map.put(nums[i], 1);
        }

        HashMap<Integer, Integer> resultMap = sortByValue(map);

        int[] result = new int[resultMap.size()];
        int i = 0;
        for(Map.Entry<Integer, Integer> entry : resultMap.entrySet()){
        result[i++] = entry.getKey();
        }

        return result;
    }

    private static <K, V extends Comparable<? super V>> HashMap<K, V> sortByValue( Map<K, V> map ){
        List<Map.Entry<K, V>> list = new LinkedList<>(map.entrySet());
        Collections.sort( list, new Comparator<Map.Entry<K, V>>(){
            @Override
            public int compare( Map.Entry<K, V> o1, Map.Entry<K, V> o2)
            {
                return ( o2.getValue() ).compareTo( o1.getValue() );
            }
        } );

        HashMap<K, V> result = new LinkedHashMap<>();
        for (Map.Entry<K, V> entry : list)
        {
            result.put( entry.getKey(), entry.getValue() );
        }
        return result;
    }

    public static void main(String[] args) {
        int[] nums = {2,2,2,2,2,1,1,3,3,3,3};
        int[] result = countSort(nums);

        for(int i = 0; i < result.length; i++)
            System.out.println(result[i]);
    }
}

下面是调试好的，用二维数组来排序的方式解决问题。

package ArraySort;

import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Set;

public class ArraySort {
    public static int[] countSort(int[] nums){
        if(nums == null || nums.length ==0)
        return null;
        HashMap<Integer, Integer> map = new HashMap<Integer, Integer>();

        for(int i = 0; i < nums.length; i++){
        if(map.containsKey(nums[i]))
            map.put(nums[i], map.get(nums[i]) + 1);
        else
            map.put(nums[i], 1);
        }

        int[][] mapNums= new int[map.size()][2];

        Set entries = map.entrySet();
        Iterator entriesIterator = entries.iterator();

        int i = 0;
        while(entriesIterator.hasNext()){

            Map.Entry mapping = (Map.Entry) entriesIterator.next();

            mapNums[i][0] = (int)mapping.getKey();
            mapNums[i][1] = (int)mapping.getValue();

            i++;
        }

        int[][] resultMap = sort(mapNums);

        int[] result = new int[map.size()];

        for(int p = 0; p < resultMap.length; p++){
            result[p] = resultMap[p][0];
        }
        return result;
    }

    public static int[][] sort(int[][] arr){
        int arr1[] = new int[2];
        for(int i = 0; i < arr.length; i++){
            for(int j = i; j < arr.length; j++){
                if(arr[i][1] < arr[j][1]){
                    arr1 = arr[i];
                    arr[i] = arr[j];
                    arr[j] = arr1;
                }
            }
        }

        return arr;
    }

//    private static <K, V extends Comparable<? super V>> HashMap<K, V> sortByValue( Map<K, V> map ){
//        List<Map.Entry<K, V>> list = new LinkedList<>(map.entrySet());
//        Collections.sort( list, new Comparator<Map.Entry<K, V>>(){
//            @Override
//            public int compare( Map.Entry<K, V> o1, Map.Entry<K, V> o2)
//            {
//                return ( o2.getValue() ).compareTo( o1.getValue() );
//            }
//        } );
//
//        HashMap<K, V> result = new LinkedHashMap<>();
//        for (Map.Entry<K, V> entry : list)
//        {
//            result.put( entry.getKey(), entry.getValue() );
//        }
//        return result;
//    }

    public static void main(String[] args) {
        int[] nums = {2,2,2,2,2,1,1,3,3,3,3};
        int[] result = countSort(nums);

        for(int i = 0; i < result.length; i++)
            System.out.println(result[i]);
    }
}