稳定排序后元素的位置

给定一个可能包含重复元素的整数数组，我们将该数组的元素提供给我们，如果应用了稳定的排序算法，我们需要告知该元素在数组中的最终位置。
例子 ：

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

解决此问题的一种简单方法是使用任何稳定的排序算法，例如插入排序，合并排序等，然后获取给定元素的新索引，但是我们可以解决此问题而无需对数组进行排序。
因为元素在排序数组中的位置仅由小于给定元素的那些元素决定。我们计算所有小于给定元素的数组元素，对于等于给定元素的那些元素，在给定元素索引之前出现的元素将包括在较小元素的计数中，这将确保结果索引的稳定性。
实现上述方法的简单代码如下：

C++

// C++ program to get index of array element in
// sorted array
#include 
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

Javascript

 
// 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.                                                

输出：

4