Count Smaller Elements on The Right Side in Java

An array or list inArr of the numbers (either negative or positive) is given. The task is to find the number of smaller elements that exist on the right side of the current element. The following examples are given for a better understanding.

Example 1:

Input

int inArr[] = {7, 4, 9, 1, 3, 5, 0, 6, 2, 8}

Output: outArr[] = {7, 4, 7, 1, 2, 2, 0, 1, 0, 0}

Explanation: For element 7, the number of smaller elements on the right side is 7 (4, 1, 3, 5, 0, 6, 2). For element 4, the number of smaller elements on the right side is 4 (1, 3, 0, 2). All the element on the right side of the number 9 is smaller than 9, and its count is 7. For element 1, only 0 is smaller on the right side. Hence, the count is 1. For 3, only two elements (0, 2) are smaller than 3. For element 5, only 0 and 2 are smaller than 5 and exist on the right side. For 0, no smaller element exists. Thus, making the count 0. For 6, only 2 is smaller than 6 (count is 1). For element 2, only 8 exits on the right side which is greater than 2. Therefore, the count is 0. For element 8, there is no element on the right side, making the count 0.

Example 2:

Input

int inArr[] = {9, 8, 7, 6, 5, 4, 3, 2, 1, 0}

Output: outArr[] = {9, 8, 7, 6, 5, 4, 3, 2, 1, 0}

Explanation: All the elements are arranged in strictly decreasing order. Also, the position of the elements in the input array is such that the count of elements on the right side is equal to the value of the element itself. For example, the number of elements on the right side of element 1 is 1 (only 0 exists on the right side). Hence, the input array becomes the answer itself.

Example 3:

Input

int inArr[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9}

Output: outArr[] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0}

Explanation: The elements are arranged in increasing order. Thus, no small elements exist on the right side if we take an element of the input array as a reference. Hence, the output array only contains 0.

Example 4:

Input

int inArr[] = {4, 4, 4, 4, 4, 4, 4, 4, 4, 4}

Output: outArr[] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0}

Explanation: All the elements of the input array are constant, i.e., of the same value. Thus, no small element exists in the input array. Therefore, all the elements of the output array are zero.

Approach: Using Nested Loop

In this approach, we will be nesting two for-loops. The outer loop picks the element from the input array (consider it as the current element). The inner loop starts from the element next to the current element and goes all the way to the end. In the inner loop, compare the elements pointed by the inner loop variable with the current element. If it is small, increase the count for the current element by 1; otherwise, do not increase the count.

FileName: CountSmallEle.java

// important import statements
import java.util.ArrayList;
import java.util.Arrays;

public class CountSmallEle 
{

public ArrayList<Integer> computeSmallEleNum(ArrayList<Integer> inArr, int s) 
{   
ArrayList<Integer> outArr = new ArrayList<Integer>();

// outer loop picks the current element
for(int i = 0; i < s; i++)
{
// for keeping the count of the elements
// that is smaller than the current element
// and are occurring on the right side
int count = 0;
for(int j = i + 1; j < s; j++)
{
if(inArr.get(i) > inArr.get(j))
{
// smaller element on the right side
// is found. Hence, increasing the 
// count by 1
count = count + 1;
}
}

// adding the count for the current element
outArr.add(count);
}


// returning the output list
return outArr;
}
    
// main method
public static void main(String argvs[])
{
// creating an object of the class CountSmallEle 
CountSmallEle obj = new CountSmallEle();

// input 1
ArrayList<Integer> inArr = new ArrayList<Integer>
(
Arrays.asList(7, 4, 9, 1, 3, 5, 0, 6, 2, 8)
);

// computing the size of the 
// input array
int size = inArr.size();
System.out.println("For the input array: ");
for(int i = 0; i < size; i++)
{
System.out.print(inArr.get(i) + " ");
}

System.out.println();
ArrayList<Integer> ans = obj.computeSmallEleNum(inArr, size);

System.out.println("The count of the smaller element on the right side is: ");
for(int i = 0; i < size; i++)
{
System.out.print(ans.get(i) + " ");
}

System.out.println( "\n" );

// input 2
inArr = new ArrayList<Integer>
(
Arrays.asList(9, 8, 7, 6, 5, 4, 3, 2, 1, 0)
);

// computing the size of the 
// input array
size = inArr.size();

System.out.println("For the input array: ");

for(int i = 0; i < size; i++)
{
System.out.print(inArr.get(i) + " ");
}

System.out.println();

ans = obj.computeSmallEleNum(inArr, size);

System.out.println("The count of the smaller element on the right side is: ");

for(int i = 0; i < size; i++)
{
System.out.print(ans.get(i) + " ");
}

System.out.println( "\n" );

// input 3
inArr = new ArrayList<Integer>
(
Arrays.asList(0, 1, 2, 3, 4, 5, 6, 7, 8, 9)
);

// computing the size of the 
// input array
size = inArr.size();

System.out.println("For the input array: ");

for(int i = 0; i < size; i++)
{
System.out.print(inArr.get(i) + " ");
}

System.out.println();

ans = obj.computeSmallEleNum(inArr, size);

System.out.println("The count of the smaller element on the right side is: ");

for(int i = 0; i < size; i++)
{
System.out.print(ans.get(i) + " ");
}

System.out.println( "\n" );


// input 4
inArr = new ArrayList<Integer>
(
Arrays.asList(4, 4, 4, 4, 4, 4, 4, 4, 4, 4)
);

// computing the size of the 
// input array
size = inArr.size();

System.out.println("For the input array: ");

for(int i = 0; i < size; i++)
{
System.out.print(inArr.get(i) + " ");
}

System.out.println();

ans = obj.computeSmallEleNum(inArr, size);

System.out.println("The count of the smaller element on the right side is: ");

for(int i = 0; i < size; i++)
{
System.out.print(ans.get(i) + " ");
}

}

}

Output:

For the input array: 
7 4 9 1 3 5 0 6 2 8 
The count of the smaller element on the right side is: 
7 4 7 1 2 2 0 1 0 0 

For the input array: 
9 8 7 6 5 4 3 2 1 0 
The count of the smaller element on the right side is: 
9 8 7 6 5 4 3 2 1 0 

For the input array: 
0 1 2 3 4 5 6 7 8 9 
The count of the smaller element on the right side is: 
0 0 0 0 0 0 0 0 0 0 

For the input array: 
4 4 4 4 4 4 4 4 4 4 
The count of the smaller element on the right side is: 
0 0 0 0 0 0 0 0 0 0

Complexity Analysis: Since the program uses nested loops, the time complexity of the program is O(N2). The program is also using extra space for storing the output. Thus, the space complexity of the program is also O(N), where N is the total number of elements present in the input array.

Approach: Using BST With Some Extra Fields

Another approach is to the simple Binary Search Tree (BST) with some of the extra fields. Those two extra fields are 1) For holding the elements on the left side of a node and 2) For keeping the element occurrence count. We will be traversing the given array from the end to the beginning and adding the elements into the Binary Search Tree. While putting the elements in the Binary Search Tree, we will be computing the count of the elements that are less than that of the current element.

Implementation

Observe the following program.

FileName: CountSmallEle1.java

// important import statement
import java.util.*;

public class CountSmallEle1
{
static Node rt = null;

// A Node class
static class Node
{
int val;
int count;
Node lft;
Node rght;

// Constructor of the class Node
Node(int n1, int n2)
{
this.val = n1;
this.count = n2;
this.lft = null;
this.rght = null;
}

}

public int computeSmallEleNum(Node rt, int val, int cntSmaller)
{

// Handling the base case
if (rt == null)
{
rt = new Node(val, 0);
return cntSmaller;
}
if (rt.val < val)
{
if(rt.rght != null)
{
return rt.count + computeSmallEleNum(rt.rght, val, cntSmaller + 1);
}
// if the control reaches here, then it
// means the right side node does not exist.
// Therefore, we will create one with the given value
rt.rght = new Node(val, 0);

return rt.count + cntSmaller + 1;
}
else
{
rt.count = rt.count + 1;
if(rt.lft != null)
{
return computeSmallEleNum(rt.lft, val, cntSmaller);
}
// if the control reaches here, then it
// means the left side node does not exist.
// Therefore, we will create one with the given value
rt.lft = new Node(val, 0);
return cntSmaller;
}
}

// Driver code
public static void main(String[] args)
{
// input 1
int arr[] = {7, 4, 9, 1, 3, 5, 0, 6, 2, 8};

// computing the size of the input array
int n = arr.length;

// auxiliary array for storing the 
// answer
int ans[] = new int[n];

// creating an object of the class CountSmallEle1
CountSmallEle1 obj = new CountSmallEle1();

// The last element of the input array is 
// the root node. Since no element exists
// after the last element. The smaller element
// count for the last element is zero.
obj.rt = new Node(arr[n - 1], 0);

// computing answer for the rest of the other elements
for(int i = n - 2; i >= 0; i--)
{
ans[i] = obj.computeSmallEleNum(obj.rt, arr[i], 0);
}

System.out.println("For the input array: ");

for(int i = 0; i < n; i++)
{
System.out.print(arr[i] + " ");
}
System.out.println();
System.out.println("The count of the smaller element on the right side is: ");
for(int i = 0; i < n; i++)
{
System.out.print(ans[i] + " ");
}

System.out.println( "\n" );

// input 2
int arr1[] = {9, 8, 7, 6, 5, 4, 3, 2, 1, 0};

// computing the size of the input array
n = arr1.length;

// auxiliary array for storing the 
// answer
int ans1[] = new int[n];

// The last element of the input array is 
// the root node. Since no element exists
// after the last element. The smaller element
// count for the last element is zero.
obj.rt = new Node(arr1[n - 1], 0);

// computing answer for the rest of the other elements
for(int i = n - 2; i >= 0; i--)
{
ans1[i] = obj.computeSmallEleNum(obj.rt, arr1[i], 0);
}
System.out.println("For the input array: ");
for(int i = 0; i < n; i++)
{
System.out.print(arr1[i] + " ");
}
System.out.println();
System.out.println("The count of the smaller element on the right side is: ");
for(int i = 0; i < n; i++)
{
System.out.print(ans1[i] + " ");
}

System.out.println( "\n" );


// input 3
int arr2[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};

// computing the size of the input array
n = arr2.length;

// auxiliary array for storing the 
// answer
int ans2[] = new int[n];

// The last element of the input array is 
// the root node. Since no element exists
// after the last element. The smaller element
// count for the last element is zero.
obj.rt = new Node(arr2[n - 1], 0);

// computing answer for the rest of the other elements
for(int i = n - 2; i >= 0; i--)
{
ans2[i] = obj.computeSmallEleNum(obj.rt, arr2[i], 0);
}
System.out.println("For the input array: ");
for(int i = 0; i < n; i++)
{
System.out.print(arr2[i] + " ");
}
System.out.println();
System.out.println("The count of the smaller element on the right side is: ");
for(int i = 0; i < n; i++)
{
System.out.print(ans2[i] + " ");
}

System.out.println( "\n" );
// input 4
int arr3[] = {4, 4, 4, 4, 4, 4, 4, 4, 4, 4};
// computing the size of the input array
n = arr3.length;
// auxiliary array for storing the 
// answer
int ans3[] = new int[n];
// The last element of the input array is 
// the root node. Since no element exists
// after the last element. The smaller element
// count for the last element is zero.
obj.rt = new Node(arr3[n - 1], 0);

// computing answer for the rest of the other elements
for(int i = n - 2; i >= 0; i--)
{
ans3[i] = obj.computeSmallEleNum(obj.rt, arr3[i], 0);
}
System.out.println("For the input array: ");
for(int i = 0; i < n; i++)
{
System.out.print(arr3[i] + " ");
}
System.out.println();
System.out.println("The count of the smaller element on the right side is: ");
for(int i = 0; i < n; i++)
{
System.out.print(ans3[i] + " ");
}
}
}

Output:

For the input array: 
7 4 9 1 3 5 0 6 2 8 
The count of the smaller element on the right side is: 
7 4 7 1 2 2 0 1 0 0 

For the input array: 
9 8 7 6 5 4 3 2 1 0 
The count of the smaller element on the right side is: 
9 8 7 6 5 4 3 2 1 0 

For the input array: 
0 1 2 3 4 5 6 7 8 9 
The count of the smaller element on the right side is: 
0 0 0 0 0 0 0 0 0 0 

For the input array: 
4 4 4 4 4 4 4 4 4 4 
The count of the smaller element on the right side is: 
0 0 0 0 0 0 0 0 0 0

Complexity Analysis: Since the added step can take O(n) time, the time complexity of the program is O(n2). The program is also using an auxiliary array for storing the result, making the space complexity of the program O(n), where n is the total number of elements present in the array.

We can do the optimization to reduce the time complexity. The following approach shows the same.

Approach: Using Self Balancing Tree

The drawback of the BST is that it is not a self-balancing tree. Thus, BST can become a skew tree leading to higher time complexity. Therefore, to do further optimization, it is required to use a self-balancing tree to compute the answer.

We will insert all the elements in the self-balancing tree one by one by traversing the input array from right to left. Whenever a new key is inserted, we check or compare it with the root element (the root element is the right-most element of the input array). If the new key is larger than the root, then it means it is larger than all of the nodes that are residing on the left side of the root node. Therefore, the size of the left subtree gets added to the count of the smaller elements for the new key that is getting inserted. The same approach is getting followed for the other nodes too.

Implementation

Observe the following program.

FileName: CountSmallEle1.java

// important import statement
import java.util.*;
public class CountSmallEle1
{
// An AVL tree node
static class AVLNode
{
	int key;
	AVLNode lft;
	AVLNode rght;
	int hght;

	// size of the rooted tree 
	int s;
};

// A method for finding the height of 
// the tree rooted with r
static int height(AVLNode r)
{
	if (r == null)
	{
	return 0;
	}
	return r.hght;
}
// A method for size of the
// tree of rooted with r
static int size(AVLNode r)
{
	if (r == null)
	{
	    return 0;
	}

	return r.s;
}
// A Method for finding the maximum
// between p and q
static int findMax(int p, int q)
{
	return (p > q) ? p : q;
}
// Helper Method for allocating the
// new node with the provided key. The method
// assigns a null value to the right and left pointers.
static AVLNode newNode(int key)
{
	AVLNode nde = new AVLNode();
	nde.key = key;
	nde.lft = null;
	nde.rght = null;

	// At leaf, the new node is added at
	// the beginning
	nde.hght = 1;
	nde.s = 1;
	return(nde);
}
// A method for doing the right rotation of the 
// subtree rooted with r
static AVLNode rightRotate(AVLNode r)
{
	AVLNode nde = r.lft;
	AVLNode T2 = nde.rght;

	// Perform rotation
	nde.rght = r;
	r.lft = T2;

	// Update heights
	r.hght = Math.max(height(r.lft), height(r.rght)) + 1;
	nde.hght = Math.max(height(nde.lft), height(nde.rght)) + 1;

	// Updating the sizes
	r.s = size(r.lft) + size(r.rght) + 1;
	nde.s = size(nde.lft) + size(nde.rght) + 1;
	// Updating the sizes
	r.s = size(r.lft) + size(r.rght) + 1;
	nde.s = size(nde.lft) + size(nde.rght) + 1;

	// Returning the new root
	return nde;
}

// A utility method for the left rotation of the 
// subtree rooted with r
public AVLNode leftRotate(AVLNode r)
{
	AVLNode nde = r.rght;
	AVLNode T2 = nde.lft;

	// Performing the rotation
	nde.lft = r;
	r.rght = T2;

	// Update heights
	r.hght = Math.max(height(r.lft), height(r.rght)) + 1;
	r.hght = Math.max(height(nde.lft), height(nde.rght)) + 1;

	// Update sizes
	r.s = size(r.lft) + size(r.rght) + 1;
	nde.s = size(nde.lft) + size(nde.rght) + 1;

	// Returning the new root
	return nde;
}
// Getting the Balance factor of the node r
public int getBalance(AVLNode r)
{
	if (r == null)
	{
	return 0;
	}

	return height(r.lft) - height(r.rght);
}

// The method inserts a new key into the AVL tree rooted with
// the node. Also, updating the count for fetching count
// of the lesser elements with the new key
public AVLNode insert(AVLNode nde, int cntSmaller[], int key, int cnt)
{
	// Performing the rotation of the BST (normal)
	if (nde == null)
	{
	return(newNode(key));
	}

	if (key < nde.key)
	{
	nde.lft = insert(nde.lft, cntSmaller, key, cnt);
	}
	else if(key > nde.key)
	{
	nde.rght = insert(nde.rght, cntSmaller, key, cnt);
	// updating the count of the lesser elementes than the key
	cntSmaller[cnt] = cntSmaller[cnt] + size(nde.lft) + 1;
	}
	
	// the key value is same as the nde value
	// hence, that key value should not be inserted
	else
	{
	    return nde;
	}


	// Updating the size and the height of this ancestor node
	nde.hght = Math.max(height(nde.lft), height(nde.rght)) + 1;
	nde.s = size(nde.lft) + size(nde.rght) + 1;

	// Getting the balance factor of the 
	// ancestor node for checking whether the
	// node has become unbalanced or not
	int balanceFactor = getBalance(nde);

	// If the node gets unbalanced,
	// then we have the 4 cases to consider

	// Handling the Left-Left Case
	if (balanceFactor > 1 && key < nde.lft.key)
	{
	return rightRotate(nde);
	}

	// Handling the Right-Right Case
	if (balanceFactor < -1 && key > nde.rght.key)
	{
	return leftRotate(nde);
	}
	// Handling the Left-Right Case
	if (balanceFactor > 1 && key > nde.lft.key)
	{
	nde.lft = leftRotate(nde.lft);
	return rightRotate(nde);
	}

	// handling the Right-Left Case
	if (balanceFactor < -1 && key < nde.rght.key)
	{
	nde.rght = rightRotate(nde.rght);
	return leftRotate(nde);
	}

	// Returning the node pointer that is unchanged
	return nde;
}

// The following method is used to update the
// cntSmaller array for containing the count of
// the smaller elements on the right side.
public void constructLowerArr(int arr[], int cntSmaller[], int size)
{
	AVLNode rt = null;

	// Initializing all of the counts in
	// the cntSmaller array with the value 0
	for(int j = 0; j < size; j++)
	{
	    cntSmaller[j] = 0;
	}

	// Beginning from the rightmost element,
	// put all of the elements one by one in
	// the AVL tree 
	for(int i = size - 1; i >= 0; i--)
	{
	rt = insert(rt, cntSmaller, arr[i], i);
	}
}


// Driver code
public static void main(String[] args)
{
// input 1
int arr[] = {7, 4, 9, 1, 3, 5, 0, 6, 2, 8};

// computing the size of the input array
int n = arr.length;

// auxiliary array for storing the 
// answer
int ans[] = new int[n];

// creating an object of the class CountSmallEle1
CountSmallEle1 obj = new CountSmallEle1();
obj.constructLowerArr(arr, ans, n);
System.out.println("For the input array: ");

for(int i = 0; i < n; i++)
{
System.out.print(arr[i] + " ");
}
System.out.println();
System.out.println("The count of the smaller element on the right side is: ");
for(int i = 0; i < n; i++)
{
System.out.print(ans[i] + " ");
}

System.out.println( "\n" );

// input 2
int arr1[] = {9, 8, 7, 6, 5, 4, 3, 2, 1, 0};

// computing the size of the input array
n = arr1.length;

// auxiliary array for storing the 
// answer
int ans1[] = new int[n];

obj.constructLowerArr(arr1, ans1, n);

System.out.println("For the input array: ");
for(int i = 0; i < n; i++)
{
System.out.print(arr1[i] + " ");
}
System.out.println();
System.out.println("The count of the smaller element on the right side is: ");
for(int i = 0; i < n; i++)
{
System.out.print(ans1[i] + " ");
}

System.out.println( "\n" );


// input 3
int arr2[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};

// computing the size of the input array
n = arr2.length;

// auxiliary array for storing the 
// answer
int ans2[] = new int[n];

obj.constructLowerArr(arr2, ans2, n);

System.out.println("For the input array: ");
for(int i = 0; i < n; i++)
{
System.out.print(arr2[i] + " ");
}
System.out.println();
System.out.println("The count of the smaller element on the right side is: ");
for(int i = 0; i < n; i++)
{
System.out.print(ans2[i] + " ");
}

System.out.println( "\n" );


// input 4
int arr3[] = {4, 4, 4, 4, 4, 4, 4, 4, 4, 4};

// computing the size of the input array
n = arr3.length;

// auxiliary array for storing the 
// answer
int ans3[] = new int[n];

obj.constructLowerArr(arr3, ans3, n);

System.out.println("For the input array: ");
for(int i = 0; i < n; i++)
{
System.out.print(arr3[i] + " ");
}
System.out.println();
System.out.println("The count of the smaller element on the right side is: ");
for(int i = 0; i < n; i++)
{
System.out.print(ans3[i] + " ");
}

}


}

Output:

For the input array: 
7 4 9 1 3 5 0 6 2 8 
The count of the smaller element on the right side is: 
7 4 7 1 2 2 0 1 0 0 

For the input array: 
9 8 7 6 5 4 3 2 1 0 
The count of the smaller element on the right side is: 
9 8 7 6 5 4 3 2 1 0 

For the input array: 
0 1 2 3 4 5 6 7 8 9 
The count of the smaller element on the right side is: 
0 0 0 0 0 0 0 0 0 0 

For the input array: 
4 4 4 4 4 4 4 4 4 4 
The count of the smaller element on the right side is: 
0 0 0 0 0 0 0 0 0 0

Complexity Analysis: The binary tree used in the above program can never be the skew tree. Thus, the time complexity of the program is O(n x log(n)), where n is the total number of nodes present in the input array. The space complexity of the program is the same as the previous program.

Next TopicInterleaving String Problem in Java

← prev next →