leetcode 1365:有多少小于当前数字的数字（计数排序详细解法！排序+HashMap！暴力解法）

问题描述

1.给你一个数组nums，对于其中每个元素nums[i]，请你统计数组中比它小的所有数字的数目
2.换而言之，对于每个 nums[i] 你必须计算出有效的 j 的数量，其中 j 满足 j != i 且 nums[j] < nums[i]
3.其中 2 < nums.length < 500，0 <= nums[i] <= 100, 以数组形式返回答案

• 示例：

输入：nums = [8,1,2,2,3]
输出：[4,0,1,1,3]
解释：对于 nums[0]=8 存在四个比它小的数字：(1，2，2 和 3）
   对于 nums[1]=1 不存在比它小的数字
   对于 nums[2]=2 存在一个比它小的数字：(1)
   对于 nums[3]=2 存在一个比它小的数字：(1)
   对于 nums[4]=3 存在三个比它小的数字：(1, 2 , 2)

一、计数排序

• 题中数组为[0-100].可以建立一个频次数组，freq[i]表示i出现的次数

1. 思路步骤（用成绩举例-便于理解）

（1）创建频次数组，得到每个元素在改数组中出现的次数

• 我们先要建一个频次数组freq[101] 编号从freq[0]~freq[100]
• 一开始，我们将 freq[0]~freq[100] 都初始化为0，表示相应的次数还没有元素出现过。例如：freq[0]=0 表示目前还没有人得零分；freq[1]=0表示还没有人得过1分；freq[100] 表示还没有人得到过100分
• 举例：{8,2,2,1,3}
  • 第一个人的分数是8分：在相对应 freq[8] 值的基础上增加1，即将 freq[8] 的值从0改为1，表示8分出现了一次
  • 第二个人的分数是2分：在相对应 freq[2] 值的基础上增加1，即将 freq[2] 的值从0改为1，表示1分出现了一次
  • 注意：第三个人的分数也是2分：在相对应 freq[2] 值的基础上在增加 1，即将 freq[2] 的值从1改为2，表示2分出现了两次

0   1   2   0   0   0   0   0   1   0   0   【元素值--出现频次】
0   1   2   3   4   5   6   7   8   9   10  【数组下边--分数】

• 即：freq[0]~freq[100]中的数值其实就是0分到100(分)每个数字(分数)出现的次数
• 即：元素值是几，就在频次数组相对应的位置上增加1，用来记录改元素出现的次数

（2）统计

• 统计某个分数出现时，计算该分数及小于该分数的分数出现的次数【即 freq[i] = freq[i] + freq[i-1]】，将次数的值赋值给该分数所在的位置
• 举例：{8,2,2,1,3} freq[9] freq的大小为原数组中元素最大值加 1 即可

0   1   3   3   3   3   3   3   4   4   4  【小于特定分数的分数在原数组中出现的次数】
0   1   2   3   4   5   6   7   8   9   10 【数组下标--分数】

（3）找到左侧第一个小于某个元素值的数，就知道数组中小于该数的数量

• 对于排序好的（即下标代表元素值排序–分数排序）频次数组，对应每个元素来说
• 遍历原数组，当元素值为0时返回0，元素值不为0时，返回频次数组中 该元素（分数–数组下标）所对应次数（数组下标对应的元素值）的前一位

2. Code

class Solution {
    public int[] smallerNumbersThanCurrent(int[] nums) {
        int[] freq = new int[101];
        for (int i = 0; i < nums.length; i++) {
            freq[nums[i]]++;
        }
        for (int i = 1; i <= 100; i++) {
            freq[i] += freq[i - 1];
        }
        int[] newNum = new int[nums.length];
        for (int i = 0; i < nums.length; i++) {
            newNum[i] = nums[i] == 0 ? 0 : freq[nums[i] - 1];
        }
        return newNum;
    }
}

二、排序（HashMap）

1. 思路步骤

• 创建一个数组作为排序数组
• 用HashMap记录排序后数组中元素值的位置，即可得知有多少小于该元素的数字个数。
• 注意：HasMap遇到重复元素时，后者会覆盖原来的值，所以我们遍历 put 时从后往前
• 为新数组（输出数组）赋值，map.get(nums[i])
• get方法得到原数组中元素的值（nums[i] 原数组中的元素值，也是map中的key值–该key值对应的value值为排序后的数组中该元素值的位置）

2. Code

class Solution {
    public int[] smallerNumbersThanCurrent(int[] nums) {
        //复制原数组到排序数组，并排序
        int[] sortArry = new int[nums.length];
        System.arraycopy(nums,0,sortArry,0,nums.length);
        Arrays.sort(sortArry);
        
        //新建HashMap,利用HashMap记录元素sortArry[i]在数组中所在位置
        HashMap<Integer,Integer> map = new HashMap<>();
        for(int i = sortArry.length - 1;i >= 0;i-- ){
            map.put(sortArry[i],i);
        }
        
        //为新数组赋值
        int[] newNum = new int[nums.length];
        for(int i = 0;i < nums.length;i++){
            newNum[i] = map.get(nums[i]);
        }
        return newNum;
    }
}

3. 简化版

class Solution {
    public int[] smallerNumbersThanCurrent(int[] nums) {
        Map<Integer, Integer> map = new HashMap<>();
        int[] sorted = Arrays.stream(nums).sorted().toArray();
        for (int i = 0; i < sorted.length; i++) {	
       		if (i == 0 || sorted[i] != sorted[i - 1]) {
        		map.put(sorted[i], i);
        	}
        }
        return Arrays.stream(nums).map(num -> map.get(num)).toArray();
	}
}

三、暴力解法

1.思路

• 定义一个用来计数的 count
• 循环遍历数组，让数组中的每一位元素与其他元素依次做比较
• 得到数组中小于当前元素的数字个数，放入新数组

2.Code

class Solution {
    public int[] smallerNumbersThanCurrent(int[] nums) {
        int[] newNum = new int[nums.length];
        for(int i = 0;i < nums.length;i++){
            int count = 0;
            for(int j = 0;j < nums.length;j++){
                if(nums[i] > nums[j]){
                    count++;
                }
            }
            newNum[i] = count;
        }
        return newNum;
    }
}