获取开始和结束索引之间的数组最大值和最小值

Question

我需要一种简单、轻量级的方法来获取双精度数组的 ma​​x 和 min 值。诀窍是我只需要数组中两个索引之间的最大值和最小值。

内置的 arrayOfDoubles.Max() 和 arrayOfDoubles.Min() 将不工作，因为它们会检查整个数组。

此代码将不断运行，并且需要有一定的效率。也就是说，简单性和可读性比速度本身更重要。

这是获取两个索引之间的最大值和最小值的一种方法：

double[] array = new double[8] { 3, 1, 15, 5, 11, 9, 13, 7 };

int startIndex = 3;
int endIndex = 6;

// Get max and min between these two indexes in the array
double max = GetMax(array, startIndex, endIndex);
double min = GetMin(array, startIndex, endIndex);

Console.WriteLine("Max = " + max + ", Min = " + min);

这是 GetMax 的代码，GetMin 非常相似：

private static double GetMax(double[] array, int startIndex, int endIndex)
{
    double max = double.MinValue;

    for (int i = startIndex; i <= endIndex; i++)
    {
        // Increase max with each bigger value
        max = Math.Max(max, array[i]);
    }

    return max;
}

输出：Max = 13, Min = 5

问题：我可以通过哪些其他方式获得相同的结果，并且可能更简单且不需要太多开销？

Answer 1

var list = array.Skip(startIndex).Take(endIndex - startIndex + 1).ToList();
var min = list.Min();
var max = list.Max();

Answer 2

你也可以这样做：

var segment = new ArraySegment<double>(array, startIndex, endIndex - startIndex + 1);
var min = segment.Min();
var max = segment.Max();

Answer 3

很明显，在 unsorted 数组中查找最小和最大元素需要 O(n) 算法，因为无论你如何做，你都必须检查每个元素，至少一次.因此，您唯一希望得到的优化是特定于实现的，并且只能在常量方面为您带来收益。

但是，您可以使用一个聪明的技巧来仅使用 3*[n/2] 比较来查找数组中的最小值和最大值。虽然这不是渐近改进，但与直接算法中所需的典型 2*n 比较相比，它是 n/2 的改进。因此，如果您希望执行大量最小/最大计算，那么可能值得考虑将其作为一个选项。

你的做法是这样的：

• 到目前为止，在两个变量中保持最小和最大元素
• 在每次迭代中：
  • 比较接下来的两个元素以确定哪个更大
  • 将较大的元素与最大值进行比较（必要时交换）
  • 将较小的元素与最小值进行比较（必要时交换）

您将执行该循环的 n/2 次迭代，每次迭代进行 3 次比较，总共 3*[n/2] 次操作。

这是一个实现：

void GetMinMax(double[] array, int start, int end, out double min, out double max)
{
    min = array[start];
    max = array[start];

    if((end - start) % 2 == 0)               // if there's an odd number of elements
       start = start + 1;                    //   skip the first one

    for (int i = start + 1; i <= end; i += 2)
    {
        if(array[i] > array[i-1])
        {
            if(array[i] > max) max = array[i];
            if(array[i - 1] < min) min = array[i - 1];
        } else {
            if(array[i - 1] > max) max = array[i - 1];
            if(array[i] < min) min = array[i];
        }
    }
}

Answer 4

您可以通过扫描阵列一次来做到这一点。这是在无数面试问题中提出的标准最小/最大跟踪算法，因此可读性应该不是问题。

void GetMinMax(double[] array, int start, int end, out double min, out double max)
{
    min = Double.MaxValue;
    max = Double.MinValue;

    // TODO: error checks for out-of-bounds, null, etc...
    for (int i = start; i <= end; ++i)
    {
        if (array[i] > max) max = array[i];
        if (array[i] < min) min = array[i];
    }
}

编辑：

使用 Usman Zafar 的 answer 来简化并消除对多个错误检查的需要：

void GetMinMax(IList<double> list, out double min, out double max)
{
    // TODO: null/empty check for list.

    min = Double.MaxValue;
    max = Double.MinValue;

    for (int i = 0; i < list.Count; ++i)
    {
        if (list[i] > max) max = list[i];
        if (list[i] < min) min = list[i];
    }
}

现在拨打任何IList<double>，或者在您的情况下：new ArraySegment<double>(array, 3, 4)。

Answer 5

使用 LINQ 的甜味剂：

        var res = array.Skip(startIndex).Take(1 + endIndex - startIndex );
        var min = res.Min();
        var max = res.Max();