[LeetCode][easy]Rank Transform of an Array

排序加 map 可以做。

/**
Runtime: 24 ms, faster than 79.61% of Java online submissions for Rank Transform of an Array.

Memory Usage: 56.1 MB, less than 100.00% of Java online submissions for Rank Transform of an Array.
*/
class Solution {
    public int[] arrayRankTransform(int[] arr) {
        if (arr == null || arr.length == 0) {
            return new int[0];
        }
        int[] tmp = Arrays.copyOf(arr, arr.length);
        Arrays.sort(tmp);
        HashMap<Integer, Integer> map = new HashMap<>();
        int index = 1;
        for (int i=0; i<tmp.length; i++) {
            if (map.get(tmp[i]) != null) {
                continue;
            }
            map.put(tmp[i], index++);
        }
        tmp = null;
        int[] result = new int[arr.length];
        for (int i=0; i<arr.length; i++) {
            result[i] = map.get(arr[i]);
        }
        return result;
    }
}

实际上，每个数字的次序就是数组里小于该数字的数字数量，故可以使用一个数组保存小于某个数字的数字数量，由于数组下标是有序的，所以就可以不用排序。

/**
Runtime: 4 ms, faster than 98.68% of Java online submissions for Rank Transform of an Array.

Memory Usage: 49.4 MB, less than 100.00% of Java online submissions for Rank Transform of an Array.
*/
class Solution {
    public int[] arrayRankTransform(int[] arr) {
        if (arr == null || arr.length == 0) {
            return new int[0];
        }
        int max = Integer.MIN_VALUE;
        int min = Integer.MAX_VALUE;
        for (int i : arr) {
            max = i > max ? i : max;
            min = i< min ? i : min;
        }
        int[] priorityOfNums = new int[max - min + 1];
        for (int i : arr) {
            priorityOfNums[i - min] = 1;
        }
        for (int i=1; i<priorityOfNums.length; i++) {
            priorityOfNums[i] += priorityOfNums[i-1];
        }
        int[] result = new int[arr.length];
        for (int i=0; i<result.length; i++) {
            result[i] = priorityOfNums[arr[i] - min];
        }
        return result;
    }
}