找到 INT 数组的第 N 个最大数的最快方法是什么？

Question

I want a faster function to find the Nth biggest number of an Int array in C#. This function takes N and Array and returns index of that number.

Here is what i have already. It simply sorts the array and then returns the index of that number. It works perfectly but I'm not sure if this is the fastest way. it seems logical to be an algorithm without complete sorting.

static int myFunction(int[] array, int N){
    int[] indexes = new int[array.Length];
    for (int i = 0; i < indexes.Length; i++)
        indexes[i] = i;

    for (int i = 0; i < array.Length; i++)
    {
        for (int j = i + 1; j < array.Length; j++)
        {
            if (array[i] < array[j])
            {
                int m = array[j];
                array[j] = array[i];
                array[i] = m;

                m = indexes[j];
                indexes[j] = indexes[i];
                indexes[i] = m;
            }
        }
    }
    return indexes[N];
}

some results:

myFunction(new int[] { 1, 3, 2, 0, 10 }, 0); //returns 4 (index of 10)
myFunction(new int[] { 1, 3, 2, 0, 10 }, 1); //returns 1 (index of 3)
myFunction(new int[] { 1, 3, 2, 0, 10 }, 2); //returns 2 (index of 2)

Answer 1

Randomized quickselect algorithm works in average case complexity O(n). Practically it's very rare to be O(n^2). It uses quicksort's partition function

Answer 2

If your array has a size of a zillion numbers and you need the fifth largest number then you are sorting a lot of numbers that you won't need.

Wouldn't it be faster to keep an ascending sorted sequence of length n (linked list?), and for every element check if it is larger than the first one (which is the smallest in the ascending order

• If smaller: skip to the next element in your large array
• If larger: remove the smallest one from your sorted array which is the first element and insert the larger element in the proper place, keep the array sorted.

After having scanned your complete array, the first element in your sorted sequence is the one you are looking for.

Most comparisons are only with the first element of your sorted array. You'll have to change the array N-times, one time for the N largest numbers. A change of the array is to remove the first element (the smallest) and find the place where to insert the new element to keep the array sorted

Correction: my statement that the array has to be changed N-time is incorrect. This can be seen most easily when offering an array sorted in ascending order: every compared number will be larger than the smallest in the N-size array, and thus cause a replace

Answer 3

This would be the implementation of @HaraldDutch's answer.

int get(int[] array, int n)
{
    var comparer = Comparer<int>.Create((x, y) => array[x].CompareTo(array[y]));    //compare the array entries, not the indices
    var highestIndices = new SortedSet<int>(comparer);
    for (var i = 0; i < array.Length; i++)
    {
        var entry = array[i];
        if (highestIndices.Count < n) highestIndices.Add(i);
        else if (array[highestIndices.Min] < entry)
        {
            highestIndices.Remove(highestIndices.Min);
            highestIndices.Add(i);
        }
    }

    return highestIndices.Min;
}

You'd have to pass in 1 instead of 0 though.

Answer 4

you need to use Selection algorithm https://en.wikipedia.org/wiki/Selection_algorithm

here nice slides: https://c3p0demo.googlecode.com/svn/trunk/scalaDemo/script/Order_statistics.ppt generally algorithm:

Select(A,n,i):
    Divide input into ⌈n/5⌉ groups of size 5.

    /* Partition on median-of-medians */
    medians = array of each group’s median.
    pivot = Select(medians, ⌈n/5⌉, ⌈n/10⌉)
    Left Array L and Right Array G = partition(A, pivot)

    /* Find ith element in L, pivot, or G */
    k = |L| + 1
    If i = k, return pivot
    If i < k, return Select(L, k-1, i)
    If i > k, return Select(G, n-k, i-k)

Answer 5

You could create a heap of size N which has the largest number as its first element (as opposed to the smallest one usually given). Then you walk through your integer array, and whenever you have an element smaller than the largest member of the heap, you insert it into the heap. If that makes the heap exceed a size of N, you remove the largest member in it.

That should be one of the cheapest ways to do this. Specific "nth largest of m" algorithms may beat it, but probably not asymptotically.

Answer 6

Your sorting algorithm is by far not the fastest. You should google for "Quicksort" for a much, much faster algorithm.

And after you have implemented Quicksort, you would then think about whether you really needed to sort the complete array. Say you want to find the 20 largest out of 10,000 numbers, why would you sort the remaining 9,980 numbers? You can easily modify Quicksort so that it will find the N largest numbers but mostly ignore the rest.

Answer 7

Maybe this could help someone. finding the nth largest number in an int array.

            int[] arr = new int[] { 3, 2, 1, 5 };
            Array.Sort(arr);
            int elemCount = 0;
            int? thirdLargestNumber = null;
            foreach (var elem in arr)
            {
                var temp = arr.Skip(elemCount).ToArray();
                if (temp.Length == 3) //replace `3` with variable.
                { 
                    thirdLargestNumber = temp[0];
                    break;
                }
                elemCount++;
            }
            Console.WriteLine($"Third largest number = {thirdLargestNumber}");