[LeetCode]--315. Count of Smaller Numbers After Self(Binary Search Tree && Merge Sort)

Problem

Problem_Link

Solutions

Binary Search Tree

So, see the code!

public class Solution {
class Node {
Node left, right;
int val, sum, dup = 1;
// "val" means the value of this node, "sum" represents the total number ofon its left bottom side.
public Node(int v, int s) {
val = v;
sum = s;
}
}
public List<Integer> countSmaller(int[] nums) {
Integer[] ans = new Integer[nums.length];
Node root = null;
for (int i = nums.length; i >= 0; i--) {
root = insert(nums[i], root, ans, i, 0);
}
return Arrays.asList(ans);
}
private Node insert(int num, Node node, Integer[] ans, int i, int preSum) {
if (node == null) {
node = new Node(num, 0);
} else if (node.val == num) {
node.dup++;
ans[i] = preSum + node.sum;
} else if (node.val > sum) {
node.sum++;
// preSum--attention
node.left = insert(num, num.left, ans, i, preSum);
} else {
// preSum + node.dup + node.sum
node.right = insert(num, num.right, ans, i, preSum + node.dup + node.sum);
}
return node;
}
}

Merge Sort Solution(Python)

Reference:https://discuss.leetcode.com/topic/31162/mergesort-solution

The smaller numbers on the right of a number are exactly those that jump from its right to its left during a stable sort. So I do mergesort with added tracking of those right-to-left jumps.

At first, I want to understand the Python Solution use the merge sort solution!

def countSmaller(self, nums):
def sort(enum):
half = len(enum) / 2
if half:
left, right = sort(enum[:half]), sort(enum[half:])
for i in range(len(enum))[::-1]:
if not right or left and left[-1][1] > right[-1][1]:
smaller[left[-1][0]] += len(right)
enum[i] = left.pop()
else:
enum[i] = right.pop()
return enum
smaller = [0] * len(nums)
sort(list(enumerate(nums)))
return smaller

Merge Sort Solution(Java)

Reference: https://discuss.leetcode.com/topic/31554/11ms-java-solution-using-merge-sort-with-explanation

The Merge Sort idea is follows!

Variables We Need

1.

left[]

and

right[]

, do the merge sort operation, supposed that

left[]

and

right[]

are already sorted.

2. rightcount is used to [record how many numbers from

right[]

.

3. count[left.length]: Because the

right[]

doesn’t need count to record this.

Variables We Do

1. Increase the rightcount by 1 when u move a number from

right[]

into the new sorted array.

2. Increase the count[index of number from the left[]] by the present value of rightcount when u move a number from

left[index]

into the new sorted array.

int[] count;
public List<Integer> countSmaller(int[] nums) {
List<Integer> res = new ArrayList<Integer>();

count = new int[nums.length];
int[] indexes = new int[nums.length];
for(int i = 0; i < nums.length; i++){
indexes[i] = i;
}
mergesort(nums, indexes, 0, nums.length - 1);
for(int i = 0; i < count.length; i++){
res.add(count[i]);
}
return res;
}
private void mergesort(int[] nums, int[] indexes, int start, int end){
if(end <= start){
return;
}
int mid = (start + end) / 2;
mergesort(nums, indexes, start, mid);
mergesort(nums, indexes, mid + 1, end);

merge(nums, indexes, start, end);
}
private void merge(int[] nums, int[] indexes, int start, int end){
int mid = (start + end) / 2;
int left_index = start;
int right_index = mid+1;
int rightcount = 0;
int[] new_indexes = new int[end - start + 1];

int sort_index = 0;
while(left_index <= mid && right_index <= end){
if(nums[indexes[right_index]] < nums[indexes[left_index]]){
new_indexes[sort_index] = indexes[right_index];
rightcount++;
right_index++;
}else{
new_indexes[sort_index] = indexes[left_index];
count[indexes[left_index]] += rightcount;
left_index++;
}
sort_index++;
}
while(left_index <= mid){
new_indexes[sort_index] = indexes[left_index];
count[indexes[left_index]] += rightcount;
left_index++;
sort_index++;
}
while(right_index <= end){
new_indexes[sort_index++] = indexes[right_index++];
}
for(int i = start; i <= end; i++){
indexes[i] = new_indexes[i - start];
}
}