Question

我创建了一个快速排序传递给函数的数组的函数，但是由于函数是递归函数，它需要2个额外的参数来帮助快速排序。在每一轮函数之后，它将左或右设置为下一个要排序的区域，依此类推。

由于这些额外的参数，每次我手动调用函数进行快速排序时，我需要添加0并将数组长度作为参数。

   Quicksort(arr,0,arr.Length);

现在这似乎可以避免，但只是在左参数（0）中添加一个默认值，但是右边的参数需要是数组的长度，在这种情况下，它将被称为元素：

   public static void QuickSort<T>(T[] elements, int left = 0, int right = elements.Length) where T : IComparable

但是无法获得元素数组的长度。

我想过制作一个简单插入0和数组长度的函数而不是我，但我想找到一种方法，如果它甚至可能没有额外的功能。谢谢高级：）

 public static void QuickSort<T>(T[] elements, int left, int right) where T : IComparable
    {
        int i = left, j = right;
        T pivot = elements[(left + right) / 2];

        while (i <= j)
        {
            while (elements[i].CompareTo(pivot) < 0)
                i++;

            while (elements[j].CompareTo(pivot) > 0)
                j--;

            if (i <= j)
            {
                T tmp = elements[i];
                elements[i++] = elements[j];
                elements[j--] = tmp;
            }
        }
        if (left < j)
            QuickSort(elements, left, j);

        if (i < right)
            QuickSort(elements, i, right);

    }

}

Answer 1

有时最简单的解决方案是最好的解决方案：添加过载。

public static void QuickSort<T>(T[] elements, int left = 0) where T : IComparable
{
    QuickSort(elements, left, elements.Length);
}

public static void QuickSort<T>(T[] elements, int left, int right) where T : IComparable
{
    // code
}

丑陋的解决方案（使用可空类型并使用null更改Length值。 null不属于right的合法域名，因此没有大问题：

public static void QuickSort<T>(T[] elements, int left = 0, int rightTemp = null) where T : IComparable
{
    int right = rightTemp ?? elements.Length;

    // code
}

Uglier解决方案（使用 -1 作为＆＃34;要替换的值＆＃34;）。 -1 （或int.MinValue）不属于right的合法域名，但这个解决方案很丑陋： - ）

public static void QuickSort<T>(T[] elements, int left = 0, int right = -1) where T : IComparable
{
    if (right == -1)
    {
        right = elements.Length;
    }

    // code
}

Answer 2

你需要一个方法，它有一个漂亮，干净，最小的签名来暴露给外面的世界，还有一个私有的递归方法来进行排序。

所以：

// this method is exposed to the outside world.
// Nobody needs to know about "left" and "right".
// Consumers of this method just want to "QuickSort" some elements. 
public static void QuickSort<T>(T[] elements) where T : IComparable
{
    // init the recursion here and forget about it
    QuickSortInternal(elements, 0 , elements.Length);
}

// this is your recursive method
private static void QuickSortInternal<T>(T[] elements, int left, int right) where T : IComparable
{
    // your code....
}

Answer 3

由于您总是通过数组本身作为第一个参数发送，因此无论如何都有长度。如果您可以从第一个参数中获取数组的长度，为什么要通过长度发送？

换句话说，稍微更改一下代码，以便每次调用Quicksort只通过一个数组发送。不要左右发送。拆分每个调用中获得的数组，然后将拆分数组发送到两个子Quicksort调用，而不是每次都向左和向右发送。

函数

3 个答案: