Skip to content
Related Articles

Related Articles

Improve Article

Position of an element after stable sort

  • Difficulty Level : Easy
  • Last Updated : 28 Jun, 2021
Geek Week

Given an array of integers which may contain duplicate elements, an element of this array is given to us, we need to tell the final position of this element in the array, if a stable sort algorithm is applied.
Examples : 
 

Input  : arr[] = [3, 4, 3, 5, 2, 3, 4, 3, 1, 5], index = 5
Output : 4
Element initial index – 5 (third 3)
After sorting array by stable sorting algorithm, we get 
array as shown below
[1(8), 2(4), 3(0), 3(2), 3(5), 3(7), 4(1), 4(6), 5(3), 5(9)]
with their initial indices shown in parentheses next to them,
Element's index after sorting = 4

 

One easy way to solve this problem is to use any stable sorting algorithm like Insertion Sort, Merge Sort etc and then get the new index of given element but we can solve this problem without sorting the array. 
As position of an element in a sorted array is decided by only those elements which are smaller than given element. We count all array elements smaller than given element and for those elements which are equal to given element, elements occurring before given elements’ index will be included in count of smaller elements this will insure the stability of the result’s index. 
Simple code to implement above approach is implemented below: 
 
 

C++




// C++ program to get index of array element in
// sorted array
#include <bits/stdc++.h>
using namespace std;
 
// Method returns the position of arr[idx] after
// performing stable-sort on array
int getIndexInSortedArray(int arr[], int n, int idx)
{
    /* Count of elements smaller than current
        element plus the equal element occurring
        before given index*/
    int result = 0;
    for (int i = 0; i < n; i++) {
        // If element is smaller then increase
        // the smaller count
        if (arr[i] < arr[idx])
            result++;
 
        // If element is equal then increase count
        // only if it occurs before
        if (arr[i] == arr[idx] && i < idx)
            result++;
    }
    return result;
}
 
// Driver code to test above methods
int main()
{
    int arr[] = { 3, 4, 3, 5, 2, 3, 4, 3, 1, 5 };
    int n = sizeof(arr) / sizeof(arr[0]);
 
    int idxOfEle = 5;
    cout << getIndexInSortedArray(arr, n, idxOfEle);
 
    return 0;
}

Java




// Java program to get index of array
// element in sorted array
 
class ArrayIndex {
 
    // Method returns the position of
    // arr[idx] after performing stable-sort
    // on array
    static int getIndexInSortedArray(int arr[],
                                     int n, int idx)
    {
        /*  Count of elements smaller than
        current element plus the equal element
        occurring before given index*/
        int result = 0;
        for (int i = 0; i < n; i++) {
 
            // If element is smaller then
            // increase the smaller count
            if (arr[i] < arr[idx])
                result++;
 
            // If element is equal then increase
            // count only if it occurs before
            if (arr[i] == arr[idx] && i < idx)
                result++;
        }
        return result;
    }
 
    // Driver code to test above methods
    public static void main(String[] args)
    {
        int arr[] = { 3, 4, 3, 5, 2, 3, 4, 3, 1, 5 };
        int n = arr.length;
 
        int idxOfEle = 5;
        System.out.println(getIndexInSortedArray(arr,
                                                 n, idxOfEle));
    }
}
 
// This code is contributed by Raghav sharma

Python




# Python program to get index of array element in
# sorted array
# Method returns the position of arr[idx] after
# performing stable-sort on array
 
def getIndexInSortedArray(arr, n, idx):
       # Count of elements smaller than current
       # element plus the equal element occurring
       # before given index
    result = 0
    for i in range(n):
        # If element is smaller then increase
        # the smaller count
        if (arr[i] < arr[idx]):
            result += 1
  
        # If element is equal then increase count
        # only if it occurs before
        if (arr[i] == arr[idx] and i < idx):
            result += 1
    return result;
  
# Driver code to test above methods
arr = [3, 4, 3, 5, 2, 3, 4, 3, 1, 5]
n = len(arr)
 
idxOfEle = 5
print getIndexInSortedArray(arr, n, idxOfEle)
 
# Contributed by: Afzal Ansari

C#




// C# program to get index of array
// element in sorted array
using System;
 
class ArrayIndex {
     
    // Method returns the position of
    // arr[idx] after performing stable-sort
    // on array
    static int getIndexInSortedArray(int[] arr,
                                     int n, int idx)
    {
        /* Count of elements smaller than
        current element plus the equal element
        occurring before given index*/
        int result = 0;
        for (int i = 0; i < n; i++) {
             
            // If element is smaller then
            // increase the smaller count
            if (arr[i] < arr[idx])
                result++;
 
            // If element is equal then increase
            // count only if it occurs before
            if (arr[i] == arr[idx] && i < idx)
                result++;
        }
        return result;
    }
 
    // Driver code to test above methods
    public static void Main()
    {
        int[] arr = { 3, 4, 3, 5, 2, 3, 4, 3, 1, 5 };
        int n = arr.Length;
 
        int idxOfEle = 5;
        Console.WriteLine(getIndexInSortedArray(arr, n,
                                            idxOfEle));
    }
}
 
// This code is contributed by vt_m

PHP




<?php
// PHP program to get index of
// array element in sorted array
 
// Method returns the position of
// arr[idx] after performing
// stable-sort on array
function getIndexInSortedArray( $arr, $n, $idx)
{
     
    /* Count of elements smaller
       than current    element plus
       the equal element occurring
       before given index */
    $result = 0;
    for($i = 0; $i < $n; $i++)
    {
         
        // If element is smaller then
        // increase the smaller count
        if ($arr[$i] < $arr[$idx])
            $result++;
 
        // If element is equal then
        // increase count only if
        // it occurs before
        if ($arr[$i] == $arr[$idx] and
                           $i < $idx)
            $result++;
    }
    return $result;
}
 
    // Driver Code
    $arr = array(3, 4, 3, 5, 2, 3, 4, 3, 1, 5);
    $n =count($arr);
 
    $idxOfEle = 5;
    echo getIndexInSortedArray($arr, $n,
                             $idxOfEle);
 
// This code is contributed by anuj_67.
?>

Javascript




<script>
 
// JavaScript program to get index of array
// element in sorted array
 
    // Method returns the position of
    // arr[idx] after performing stable-sort
    // on array
    function getIndexInSortedArray(arr,
                                     n, idx)
    {
        /*  Count of elements smaller than
        current element plus the equal element
        occurring before given index*/
        let result = 0;
        for (let i = 0; i < n; i++) {
   
            // If element is smaller then
            // increase the smaller count
            if (arr[i] < arr[idx])
                result++;
   
            // If element is equal then increase
            // count only if it occurs before
            if (arr[i] == arr[idx] && i < idx)
                result++;
        }
        return result;
    }
 
// Driver Code
        let arr = [ 3, 4, 3, 5, 2, 3, 4, 3, 1, 5 ];
        let n = arr.length;
   
        let idxOfEle = 5;
        document.write(getIndexInSortedArray(arr,
                                                 n, idxOfEle));
                                                  
// This code is contributed by code_hunt.                                                
</script>

Output: 
 

4

This article is contributed by Utkarsh Trivedi. If you like GeeksforGeeks and would like to contribute, you can also write an article using write.geeksforgeeks.org or mail your article to review-team@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.
Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above.
 

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.




My Personal Notes arrow_drop_up
Recommended Articles
Page :