[LeetCode] 315. Count of Smaller Numbers After Self

You are given an integer array nums and you have to return a new counts array. The counts array has the property where counts[i] is the number of smaller elements to the right of nums[i].

Example 1:

Input: nums = [5,2,6,1]
Output: [2,1,1,0]
Explanation:
To the right of 5 there are 2 smaller elements (2 and 1).
To the right of 2 there is only 1 smaller element (1).
To the right of 6 there is 1 smaller element (1).
To the right of 1 there is 0 smaller element.

Example 2:

Input: nums = [-1]
Output: [0]

Example 3:

Input: nums = [-1,-1]
Output: [0,0]

Constraints:

• 1 <= nums.length <= 105
• -104 <= nums[i] <= 104

计算右侧小于当前元素的个数。

给你一个整数数组 nums ，按要求返回一个新数组 counts 。数组 counts 有该性质： counts[i] 的值是  nums[i] 右侧小于 nums[i] 的元素的数量。

来源：力扣（LeetCode）
链接：https://leetcode.cn/problems/count-of-smaller-numbers-after-self
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

题意是给一个数组，请你返回一个等长的 list，表示当前位置的右侧小于 nums[i] 的元素个数。

暴力解是O(n^2)的复杂度，肯定是不行的。我这里给出一个二分法的思路。创建一个跟 input 数组等长的 arr 数组记录结果，同时再创建一个空的 list 做插入排序。数组从右往左扫描，对于每一个元素，我们把他插入到 list 一个合适的位置，使得 list 最后依然是升序排列的。这个插入的动作，比较高效的做法就是用二分。这个元素当时被插入list的index，同时也是这个元素的右侧有多少个元素小于他自己的个数。

跑一个例子，nums = [5,2,6,1]。一开始插入 input 数组的最后一个元素1的时候，由于此时 list 为空，所以插入 1 的时候，他在 list 的 index 是 0，而且在原数组中最后一个元素的右边没有比他更小的元素了；接着我们再试图把6放入list，此时他在list的index会是1（list = {1, 6}），说明在原数组中，6的右侧有一个元素比他小。

时间O(nlogn)

空间O(n)

Java实现

class Solution {
    public List<Integer> countSmaller(int[] nums) {
        // 返回结果
        List<Integer> res = new ArrayList<>();
        // 数组长度为0，直接返回
        if (nums.length == 0) {
            return res;
        }
        // 为了提高效率，新建一个数组型的返回结果
        int[] arr = new int[nums.length];
        // 新建一个list，用于排序
        List<Integer> list = new ArrayList<>();
        // 从数组最后一位开始向前循环
        for (int i = nums.length - 1; i >= 0; i--) {
            // 当前数字
            int num = nums[i];
            // 将当前数字插入到新建list中
            // 使用二分查找找到插入位置
            int left = 0;
            int right = list.size() - 1;
            while (left <= right) {
                int mid = (left + right) / 2;
                if (num <= list.get(mid)) {
                    right = mid - 1;
                } else {
                    left = mid + 1;
                }
            }
            // 将当前数字插入到相应位置，保证list升序排列
            list.add(left, num);
            // 当前位置前所有数字均小于当前数字，将个数加入返回结果
            arr[i] = left;
        }
        // 将list转化为数组
        for (int count : arr) {
            res.add(count);
        }
        return res;
    }
}

 

JavaScript实现

/**
 * @param {number[]} nums
 * @return {number[]}
 */
var countSmaller = function(nums) {
    let res = [];
    // corner case
    if (nums == null || nums.length == 0) {
        return nums;
    }

    // normal case
    let len = nums.length;
    let arr = new Array(len).fill(0);
    let list = [];
    for (let i = len - 1; i >= 0; i--) {
        let num = nums[i];
        let left = 0;
        let right = list.length - 1;
        while (left <= right) {
            let mid = Math.floor(left + (right - left) / 2);
            if (num <= list[mid]) {
                right = mid - 1;
            } else {
                left = mid + 1;
            }
        }
        list.splice(left, 0, num);
        arr[i] = left;
    }
    for (let count of arr) {
        res.push(count);
    }
    return res;
};

 

相关题目

315. Count of Smaller Numbers After Self

1365. How Many Numbers Are Smaller Than the Current Number

LeetCode 题目总结