在C＃中递归实现QuickSort

Question

I started learning algorithms and I am trying to implement Quicksort in C#. This is my code:

class QuickSortDemo
{
    public void Swap(ref int InputA, ref int InputB)
    {
        InputA = InputA + InputB;
        InputB = InputA - InputB;
        InputA = InputA - InputB;
    }

    public int Partition(int[] InputArray, int Low, int High)
    {
        int Pivot = InputArray[Low];
        int LoopVariable1 = Low - 1;
        int LoopVariable2 = High + 1;
        while (true)
        {

            while (InputArray[--LoopVariable2] > Pivot) ;

            while (InputArray[++LoopVariable1] < Pivot) ;


            if (LoopVariable1 < LoopVariable2)
            {
                Swap(ref InputArray[LoopVariable1], ref InputArray[LoopVariable2]);
                for (int LoopVariable = Low; LoopVariable <= High; LoopVariable++)
                {
                    Console.Write(InputArray[LoopVariable] + " ");
                }
                Console.WriteLine();

            }
            else
            {
                for (int LoopVariable = Low; LoopVariable <= High; LoopVariable++)
                {
                    Console.Write(InputArray[LoopVariable] + " ");
                }
                Console.WriteLine();
                return LoopVariable2;
            }
        }
    }

    public void QuickSort(int[] InputArray,int Low, int High)
    {
        if (Low < High)
        {
            int Mid = Partition(InputArray, Low, High);
            QuickSort(InputArray, Low, Mid);
            QuickSort(InputArray, Mid + 1, High);
        }
    }
    public static void Main()
    {
        int[] InputArray = { 10, 5, 6, 8, 23, 19, 12, 17 };
        QuickSortDemo Demo = new QuickSortDemo();
        for (int LoopVariable = 0; LoopVariable < InputArray.Length; LoopVariable++)
        {
            Console.Write(InputArray[LoopVariable]+" ");
        }
        Console.WriteLine();

        Demo.QuickSort(InputArray, 0, InputArray.Length - 1);
        for (int LoopVariable = 0; LoopVariable < InputArray.Length; LoopVariable++)
        {
            Console.Write(InputArray[LoopVariable] + " ");
        }
        Console.WriteLine();
    }
}

For some reason I can't get this to work when I take the rightmost element in the array as pivot. I don't know what I am doing wrong. It would be really helpful if someone could explain me why this doesn't work when I take my rightmost element as the pivot. From what I learned, this should work for any input and any pivot element. Correct me if I am wrong. Thank you.

Answer 1

I'm still not entirely sure I understand the question. But I was able to reproduce a problem (infinite recursion) when I change the line of code in the Partition() method from int pivot = inputArray[low]; to int pivot = inputArray[high]; , and doing so seems consistent with your narrative:

I can't get this to work when I take the rightmost element in the array as pivot.

If I've understood the question correctly, then the basic problem is that when you change where you get the pivot, you also need to take this into account when returning the new mid-point. Currently, you return loopVariable2 , which is correct when picking the pivot from the lower end of the array. But if you switch to picking the pivot from the upper end of the array, you need to return loopVariable2 - 1 .

Another problem is that as you are scanning, you unconditionally increment or decrement the respective "loop variable", regardless of whether the current index is already at an element in the wrong partition. You need to check the current element position first, and only adjust the index if that element is in the correct partition.

Here is a correct version of the Partition() method where the pivot is selected using high instead of low :

    public int Partition(int[] inputArray, int low, int high)
    {
        int pivot = inputArray[high];
        int loopVariable1 = low;
        int loopVariable2 = high;
        while (true)
        {

            while (inputArray[loopVariable2] > pivot) loopVariable2--;

            while (inputArray[loopVariable1] < pivot) loopVariable1++;


            if (loopVariable1 < loopVariable2)
            {
                Swap(ref inputArray[loopVariable1], ref inputArray[loopVariable2]);
                for (int loopVariable = low; loopVariable <= high; loopVariable++)
                {
                    Console.Write(inputArray[loopVariable] + " ");
                }
                Console.WriteLine();

            }
            else
            {
                for (int loopVariable = low; loopVariable <= high; loopVariable++)
                {
                    Console.Write(inputArray[loopVariable] + " ");
                }
                Console.WriteLine();
                return loopVariable2 - 1;
            }
        }
    }

In either case, note that the effect is to ensure that regardless of the pivot value selected, you always partition the array in such a way to ensure that a new pivot is always selected with each level of recursion, preventing the infinite loop.

By the way, and for what it's worth, I would not implement Swap() as you have. It's an interesting gimmick to do a no-temp-variable swap, but there is no practical benefit to doing so, while it does incur a significant code maintenance and comprehension cost. In addition, it will only work with integral numeric types; what if you want to extend your sort implementation to handle other types? Eg ones that implement IComparable or where you allow the caller to provide an IComparer implementation?

IMHO a better Swap() method looks like this:

    public void Swap<T>(ref T inputA, ref T inputB)
    {
        T temp = inputA;

        inputA = inputB;
        inputB = temp;
    }

Answer 2

quick sort:

   static public int Partition(int [] numbers, int left, int right)
    {
        int pivot = numbers[left];
          while (true)
          {
            while (numbers[left] < pivot)
                left++;

            while (numbers[right] > pivot)
                right--;

            if (left < right)
                {
                int temp = numbers[right];
                numbers[right] = numbers[left];
                numbers[left] = temp;
                }
                else
                {
                      return right;
                }
          }
    }

    static public void QuickSort_Recursive(int [] arr, int left, int right)
    {
        // For Recusrion
        if(left < right)
        {
            int pivot = Partition(arr, left, right);

            if(pivot > 1)
                QuickSort_Recursive(arr, left, pivot - 1);

            if(pivot + 1 < right)
                QuickSort_Recursive(arr, pivot + 1, right);
        }
    }