如何在不排序的double类型无序数组中找出指定数量的最大值？

Got it, let's figure out how to pull the top N largest values from a double array without sorting the whole thing—this is actually simpler than it sounds once you break down the logic!

Core Idea #

Instead of sorting the entire array (which can be overkill if you only need a few top values), we'll use a straightforward iterative approach:

• Loop N times (once for each max value we need to grab)
• In each loop, scan the array to find the current largest unselected value
• Keep track of which values we've already picked so we don't select them again
• Collect these top values into our final result set

C# Implementation #

Here's a concrete method that does exactly this, with comments walking through each step:

using System;

public class TopValueFinder
{
    public static double[] GetTopNMaxValues(double[] originalArray, int numberOfValues)
    {
        // Handle edge cases first to avoid crashes
        if (originalArray == null || originalArray.Length == 0)
            throw new ArgumentException("Original array can't be null or empty.");
        if (numberOfValues < 1 || numberOfValues > originalArray.Length)
            throw new ArgumentOutOfRangeException(nameof(numberOfValues), 
                "Number of values must be between 1 and the array's length.");

        // Boolean array to track which elements we've already selected (so we don't pick duplicates)
        bool[] isSelected = new bool[originalArray.Length];
        double[] result = new double[numberOfValues];

        for (int i = 0; i < numberOfValues; i++)
        {
            double currentMax = double.MinValue;
            int currentMaxIndex = -1;

            // Scan the array to find the largest unselected value
            for (int j = 0; j < originalArray.Length; j++)
            {
                if (!isSelected[j] && originalArray[j] > currentMax)
                {
                    currentMax = originalArray[j];
                    currentMaxIndex = j;
                }
            }

            // Add the found max to our result and mark it as selected
            result[i] = currentMax;
            isSelected[currentMaxIndex] = true;
        }

        return result;
    }

    // Test with your example data!
    public static void Main()
    {
        double[] arr = new double[] {12.1, 5.9, 2.9, 6.8, 20.5};
        int n = 3;
        double[] topValues = GetTopNMaxValues(arr, n);
        
        Console.WriteLine(string.Join(", ", topValues));
        // Output: 20.5, 12.1, 6.8
    }
}

Key Details to Note #

• Preserves original data: We use a bool[] isSelected to track picked elements instead of modifying the original array—so your source data stays untouched for other uses.
• Error prevention: The method checks for invalid inputs (like null arrays or N values that are too big/small) to avoid unexpected behavior.
• Efficiency tradeoff: For small N values, this is more efficient than sorting the entire array (sorting is O(n log n), while this approach is O(N * M) where M is the array length—perfect if you only need a handful of top values).

Walkthrough of Your Example #

For arr = {12.1, 5.9, 2.9, 6.8, 20.5} and N=3:

1. First loop: Scans the array, finds 20.5 as the max, marks index 4 as selected.
2. Second loop: Skips index 4, finds 12.1 as the next largest value, marks index 0 as selected.
3. Third loop: Skips indexes 0 and 4, finds 6.8 as the third largest value, marks index 3 as selected.
4. Returns the result array {20.5, 12.1, 6.8}.

内容的提问来源于stack exchange，提问作者nat1