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:

Input: [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.

//Input: [5,2,6,1]
        //Output: [2,1,1,0]
        public static int[] CountSmaller(int[] nums)
        {
            List<int> sortList = new List<int>();
            int[] returnArr = new int[nums.Length];
            for (int i = nums.Length - 1; i >= 0; i--)
            {
                int beginIndex = 0;
                int endIndex = sortList.Count - 1;
                int insertIndex = 0;
                
                while (beginIndex <= endIndex)
                {
                    int mid = (beginIndex + endIndex) / 2;
                    if (nums[i] < sortList[mid])
                    {
                        endIndex = mid - 1;
                        if (endIndex < beginIndex)
                        {
                            insertIndex = beginIndex;
                            break;
                        }
                        else if (nums[i] > sortList[endIndex])
                        {
                            insertIndex = endIndex + 1;
                            break;
                        }
                    }
                    else if (nums[i] > sortList[mid])
                    {
                        beginIndex = mid + 1;
                        if (endIndex < beginIndex)
                        {
                            insertIndex = beginIndex;
                            break;
                        }
                        else if (nums[i] < sortList[beginIndex])
                        {
                            insertIndex = beginIndex;
                            break;
                        }
                    }
                    else
                    {
                        insertIndex = mid;
                        break;
                    }
                }
                //插入的位置排序数字有可能跟前一个或者多个数字相同
                if (sortList.Count > 0 && insertIndex<sortList.Count)
                {
                    while (sortList[insertIndex] == nums[i])
                    {
                        insertIndex--;
                    }
                }                
                sortList.Insert(insertIndex, nums[i]);
                returnArr[i] = insertIndex;
            }
            return returnArr;
        }