如何在c#中的一维数组中找到下一个最小值

Question

我想在一维数组中找到下一个最小值，这样我就不想先对数组进行排序。

例如，如果我有这个数组：

int [] a={10,5,20,3};

第一个最小值是 3，第二个是 5，第三个是 10，最后一个是 20。

现在我想分别知道最小值的索引号。 第一个最小值的索引号和第二个最小值的索引号，第三个值的索引号...

我在c#怎么办？

我认为通过使用两个循环并遍历演示文稿，可以确定下一个最小值。

Answer 1

是的，拖环是可能的。 我不知道 C# 语法，但我可以在 C 中给你答案：

int next_min (int* array ,int sizeofarray)
{
    int i , fmin , smin;
    fmin = array[0];
    for (i=0 , i<sizeofarray , i++)
    {
        if (array[i]<fmin)
        {
            fmin = array[i];
        }
    }

    smin = array[0];
    for (i=0 , i<sizeofarray , i++)
    {
        if (array[i]<smin && smin !=fmin)
        {
            min = array[i];
        }
    }
    return smin ;
}

Answer 2

class Program
{
        static void Main(string[] args)
        {
            int[] a = { 10, 5, 20, 3 };
            int[] aCopy = new int[a.Length];
            Array.Copy(a, aCopy, a.Length);
            Array.Sort(aCopy);
            var result = string.Empty;
            foreach(int value in aCopy)
            {
                result += $"({value}, {Array.IndexOf(a, value)})\n";
            }
            Console.WriteLine(result);
        }
}

Answer 3

使用获取数组并根据已知最大值查找数组中的最小值的方法。 在循环中调用该方法以按顺序获得第一个、第二个、第三个等等最小值。 始终使用上一个循环中确定的最小值作为下一个循环中的已知最大值。

internal class Program
{
    /// <summary>
    /// Finds the minimum value in values that is bigger than knownMaximum
    /// </summary>
    /// <returns>´Found minimum value and zero-based position</returns>
    static (int? minValue, int? position) GetNextMinimum(int[] values, int? knownMaximum)
    {
        int? minValue = null; 
        int? position = null;

        for(int i=0; i< values.Length; i++)
        {
            int value = values[i];
            
            // If the current value is bigger than knownMaximum or no know Maximum specified
            if(!knownMaximum.HasValue || value > knownMaximum.Value )
            {
                // If current value is smaller than minimum value so far
                if(!minValue.HasValue || value < minValue.Value)
                {
                    // Remember current value and position as minimum
                    minValue= value;
                    position= i;
                }
            }
        }

        return (minValue, position);
    }

    static void Main(string[] args)
    {
        int[] values = { 10, 5, 20, 3 };
        int? knownMaximum = null;

        // Get 1st, 2nd and 3rd Minimum
        for (int i=1; i<=3; i++)
        {
            var (minValue, position) = GetNextMinimum(values, knownMaximum);
            Console.WriteLine($"{i}\t Position {position}\t Value {minValue}");
            
            // Use the current minValue as known Maximum for nect round
            knownMaximum = minValue;
        }
    }
}

Answer 4

使用Array.Sort(Array, Array)方法，您可以按第一个中的值对两个并行的 arrays 进行排序。 要在您的示例中使用它，第一个数组（键）将包含要排序的值，第二个数组是结果的原始索引。

int[] a={10,5,20,3};
int[] indexes = Enumerable.Range(0, a.Length).ToArray(); // = { 0,1,2,3 }
Array.Sort(a, indexes);
foreach (var i in indexes)
  Console.WriteLine(i);

如果您稍后仍需要原始数组，请确保在调用 Sort 之前复制它。