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:

Given nums = [5, 2, 6, 1]

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.

Return the array [2, 1, 1, 0].

含义：针对一个数组，找到每一位的右面有多少个数小于它的值，没有的话就是0，返回数组

思路一：从后往前用二分插入法来倒排数组，后面的数字个数即为比当前数字小的数字

    public List<Integer> countSmaller(int[] nums) {
        int[] smaller = new int[nums.length];
        for(int i=nums.length-2; i>=0; i--) {
//            从后往前遍历nums,采用二分插入排序的方式，将数组进行降序排列
// 取出nums[i]后保存到temp，从i+1到末尾间找到nums[i]应该存在的位置（从i+1到末尾是降序排列），比如是left
            int left = i+1;
            int right = nums.length-1;
            while (left<=right) {
                int m = (left+right)/2;
                if (nums[i] > nums[m]) right = m - 1;
                else left = m + 1;
            }
            smaller[i] = nums.length - left; //left后面的所有数都比nums[i]小
            int temp = nums[i];
            for(int j=i; j<right; j++) nums[j] = nums[j+1]; //把i和right之间的数据依次往前移动，空出right位置用于放置nums[i]
            nums[right] = temp;
        }

            return Arrays.stream(smaller)
                         .boxed()
                         .collect(Collectors.toList());

    }

方法二：

public class Solution {
    private class TreeNode {
        public int val;
        public int count = 1;
        public TreeNode left, right;

        public TreeNode(int val) {
            this.val = val;
        }
    }

    public List<Integer> countSmaller(int[] nums) {
//        构造一棵二分搜索树，稍有不同的地方是我们需要加一个变量smaller来记录比当前节点值小的所有节点的个数，我们每插入一个节点，会判断其和根节点的大小，
//        如果新的节点值小于根节点值，则其会插入到左子树中，我们此时要增加根节点的smaller，并继续递归调用左子节点的insert。
//        如果节点值大于根节点值，则需要递归调用右子节点的insert并加上根节点的smaller，并加1
        
        List<Integer> res = new ArrayList<>();
        if(nums == null || nums.length == 0) {
            return res;
        }
        TreeNode root = new TreeNode(nums[nums.length - 1]);
        res.add(0);

        for(int i = nums.length - 2; i >= 0; i--) {
            int count = addNode(root, nums[i]);
            res.add(count);
        }

        Collections.reverse(res);
        return res;
    }

    private int addNode(TreeNode root, int val) {
        int curCount = 0;
        while(true) {
            if(val <= root.val) {
                root.count++;                   // add the inversion count
                if(root.left == null) {
                    root.left = new TreeNode(val);
                    break;
                } else {
                    root = root.left;
                }
            } else {
                curCount += root.count;
                if(root.right == null) {
                    root.right = new TreeNode(val);
                    break;
                } else {
                    root = root.right;
                }
            }
        }

        return curCount;
    }