快速排序（C#实现）

快排是对冒泡排序的一种改进。基本思想是：

通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。

C#

快排递归实现：

        internal static void QuickSort(int[] inputArray, int lowIndex, int highIndex)
        {
            if (lowIndex >= highIndex)
            {
                return;
            }
            int middleIndex = SortFunction(inputArray, lowIndex, highIndex);
            QuickSort(inputArray, lowIndex, middleIndex);
            QuickSort(inputArray, middleIndex + 1, highIndex);
        }

        private static int SortFunction(int[] inputArray, int lowIndex, int highIndex)
        {
            int minValue = inputArray[lowIndex];
            for (; highIndex > lowIndex; highIndex--)
            {
                if (inputArray[highIndex] <= minValue)
                {
                    inputArray[lowIndex] = inputArray[highIndex];
                    for (; lowIndex < highIndex; lowIndex++)
                    {
                        if (inputArray[lowIndex] >= minValue)
                        {
                            inputArray[highIndex] = inputArray[lowIndex];
                            break;
                        }
                    }
                }
            }
            inputArray[lowIndex] = minValue;
            return lowIndex;
        }

快排非递归实现：

        static void Main(string[] args)
        {
            int[] array = new int[] { 2,3,9,1,8,6};
            Stack<int> stack = new Stack<int>();
            stack.Push(0);
            stack.Push(array.Length - 1);
            while (stack.Count > 0)
            {
                int low = stack.Pop();
                int high = stack.Pop();
                if (low > high)
                {
                    low = low + high;
                    high = low - high;
                    low = low - high;
                }
                QuickSort(array, low, high, stack);
            }
        }

        internal static void QuickSort(int[] inputArray, int lowIndex, int highIndex, Stack<int> stack)
        {
            int low = lowIndex;
            int high = highIndex;
            int minValue = inputArray[lowIndex];
            while (high > low)
            {
                while (low < high && minValue <= inputArray[high])
                {
                    high--;
                }
                if (high > low)
                {
                    inputArray[low] = inputArray[high];
                }
                while (low < high && minValue >= inputArray[low])
                {
                    low++;
                }
                if (high > low)
                {
                    inputArray[high] = inputArray[low];
                }

                if (low == high)
                {
                    inputArray[low] = minValue;
                    if (lowIndex < low - 1)
                    {
                        stack.Push(lowIndex);
                        stack.Push(low -1);
                    }
                    if (highIndex > low + 1)
                    {
                        stack.Push(low + 1);
                        stack.Push(highIndex);
                    }
                }
            }
        }

快排是一种不稳定的排序。快排的最差时间复杂度是o（n²），理想时间复杂度是o（nlogn）。