函数中数组参数长度的默认参数值

Question

I made a function that quicksorts an array that is passed through the to the function but due to the function being a recursive one it takes 2 extra parameters that aid with the quick sort.

After each round of the function it sets left or right as the next area to sort and so on.

And due to these extra parameters every time I manually call the function to do a quick sort I need to add 0 and the array length as the parameters.

Quicksort(arr, 0, arr.Length);

This seems like it can be avoided but simply adding a default value to the left parameter (0) but the right parameter would need to be the length of the array which in this case is called elements , it would be:

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

but getting the length of the elements array is not possible.

I thought about making a function that would simply insert 0 and the length of the array instead of me but I wanted to find a way to do it without an extra function if it is possible.

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

Sometimes the easiest solution is the best one: add an overload.

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
}

Ugly solution (use a nullable type and change the null vale with the Length ). null isn't part of the legal domain of right , so no big problem:

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

    // code
}

Uglier solution (use -1 as the "value-to-be-replaced"). -1 (or int.MinValue ) isn't part of the legal domain of right , but this solution is ugly as hell :-)

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

You need a method with a nice, clean, minimal signature to expose to the outside world and a private recursive method that will do the sorting.

So:

// 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

Since you are always sending through the array itself as the first parameter, you have the length anyway. Why send through the length at all, if you can just get the length of the array from the first parameter?

In other words, change the code a bit, so that each call to Quicksort sends through an array only. Dont send left and right at all. Split the array you get in in each call, and then send the split array to the two sub Quicksort calls, without sending left and right each time.