适用 C# 语言实现升序/降序的 “基数排序”、“堆排序”、“桶排序”、“快速排序”、“选择排序”、“冒泡排序” 等算法

可以被模板函数实现排序算法：

1、堆排序

     分：大顶堆、小顶堆

2、快速排序

3、冒泡排序

4、选择排序

适用于整数数值的排序算法

1、基数排序（矢量排序）

2、桶排序

性能最高排序算法

1、桶排序【堆内存负载重：O(n + k)】

2、基数排序

3、快速排序

测试用例：

测试数组：var array = new int[] { 73, 57, 49, 99, 133, 20, 1 };

1、堆排序：HeapSort(array, false);

2、基数排序：RadixSort(array, false);

3、快速排序：QuickSort(array, false);

4、桶排序：BucketSort2(array, false);

本文实现的排序算法：

1、快速排序（QuickSort）

2、选择排序（SelectSort）

3、冒泡排序（BubbleSort）

4、桶排序（BucketSort）

5、基数排序（RadixSort）

6、堆排序（HeapSort）

        /* 快速排序 */
        public static void QuickSort<T>(IList<T> array, bool ascending) /* T(N) = 2T(N/2) + O(N) */
            where T : IComparable<T>
        {
            if (array == null || array.Count < 2)
            {
                return;
            }

            void SortArrayAscending(IList<T> array, int leftIndex, int rightIndex)
            {
                var i = leftIndex;
                var j = rightIndex;
                var pivot = array[leftIndex];
                while (i <= j)
                {
                    while (array[i].CompareTo(pivot) < 0)
                    {
                        i++;
                    }

                    while (array[j].CompareTo(pivot) > 0)
                    {
                        j--;
                    }

                    if (i <= j)
                    {
                        T temp = array[i];
                        array[i] = array[j];
                        array[j] = temp;
                        i++;
                        j--;
                    }
                }

                if (leftIndex < j)
                {
                    SortArrayAscending(array, leftIndex, j);
                }

                if (i < rightIndex)
                {
                    SortArrayAscending(array, i, rightIndex);
                }
            }

            void SortArrayDescending(IList<T> array, int leftIndex, int rightIndex)
            {
                var i = leftIndex;
                var j = rightIndex;
                var pivot = array[leftIndex];
                while (i <= j)
                {
                    while (array[i].CompareTo(pivot) > 0)
                    {
                        i++;
                    }

                    while (array[j].CompareTo(pivot) < 0)
                    {
                        j--;
                    }

                    if (i <= j)
                    {
                        T temp = array[i];
                        array[i] = array[j];
                        array[j] = temp;
                        i++;
                        j--;
                    }
                }

                if (leftIndex < j)
                {
                    SortArrayDescending(array, leftIndex, j);
                }

                if (i < rightIndex)
                {
                    SortArrayDescending(array, i, rightIndex);
                }
            }

            if (ascending)
            {
                SortArrayAscending(array, 0, array.Count - 1);
            }
            else
            {
                SortArrayDescending(array, 0, array.Count - 1);
            }
        }

        /* 选择排序 */
        public static void SelectSort<T>(IList<T> array, bool ascending)
            where T : IComparable<T>
        {
            if (array == null || array.Count < 2)
            {
                return;
            }

            var length = array.Count;
            if (ascending)
            {
                for (var i = 0; i < length; i++)
                {
                    for (var j = i; j < length; j++)
                    {
                        var pivot = array[i];
                        if (pivot.CompareTo(array[j]) > 0)
                        {
                            array[i] = array[j];
                            array[j] = pivot;
                        }
                    }
                }
            }
            else
            {
                for (var i = 0; i < length; i++)
                {
                    for (var j = i; j < length; j++)
                    {
                        var pivot = array[i];
                        if (pivot.CompareTo(array[j]) < 0)
                        {
                            array[i] = array[j];
                            array[j] = pivot;
                        }
                    }
                }
            }
        }

        /* 冒泡排序 */
        public static void BubbleSort<T>(IList<T> array, bool ascending)
            where T : IComparable<T>
        {
            if (array == null || array.Count < 2)
            {
                return;
            }

            var length = array.Count;
            if (ascending)
            {
                for (var i = 0; i < length; i++)
                {
                    for (var j = 0; j < length; j++)
                    {
                        var pivot = array[i];
                        if (pivot.CompareTo(array[j]) < 0)
                        {
                            array[i] = array[j];
                            array[j] = pivot;
                        }
                    }
                }
            }
            else
            {
                for (var i = 0; i < length; i++)
                {
                    for (var j = 0; j < length; j++)
                    {
                        var pivot = array[i];
                        if (pivot.CompareTo(array[j]) > 0)
                        {
                            array[i] = array[j];
                            array[j] = pivot;
                        }
                    }
                }
            }
        }

        /* 桶排序 */
        public static IList<int> BucketSort(IList<int> array, bool ascending) /* RAM:O(n + k), CPU:O（N2）*/
        {
            if (array == null || array.Count < 2)
            {
                return array;
            }

            var sortedList = new List<int>();
            var minValue = array[0];
            var maxValue = array[0];
            for (var i = 1; i < array.Count; i++)
            {
                if (array[i] > maxValue)
                {
                    maxValue = array[i];
                }

                if (array[i] < minValue)
                {
                    minValue = array[i];
                }
            }

            var numberOfBuckets = maxValue - minValue + 1;
            var bucket = new List<int>[numberOfBuckets];
            for (var i = 0; i < numberOfBuckets; i++)
            {
                bucket[i] = new List<int>();
            }

            for (var i = 0; i < array.Count; i++)
            {
                var selectedBucket = (array[i] / numberOfBuckets);
                bucket[selectedBucket].Add(array[i]);
            }

            if (ascending)
            {
                for (var i = 0; i < numberOfBuckets; i++)
                {
                    var selectedBucket = bucket[i];
                    QuickSort(selectedBucket, true);
                    sortedList.AddRange(selectedBucket);
                }
            }
            else
            {
                for (var i = numberOfBuckets - 1; i > ~0; i--)
                {
                    var selectedBucket = bucket[i];
                    QuickSort(selectedBucket, false);
                    sortedList.AddRange(selectedBucket);
                }
            }
            return sortedList;
        }

        /* 桶排序 */
        public static void BucketSort2(IList<int> array, bool ascending)
        {
            var result = BucketSort(array, ascending);
            if (result == null || result.Count < 2)
            {
                return;
            }

            var length = result.Count;
            for (var i = 0; i < length; i++)
            {
                array[i] = result[i];
            }
        }

        /* 基数排序 */
        public static void RadixSort(IList<int> array, bool ascending, int vectorX = 10, int vectorY = 100)
        {
            if (ascending)
            {
                RadixSortAscending(array, vectorX, vectorY);
            }
            else
            {
                RadixSortDescending(array, vectorX, vectorY);
            }
        }

        /* 基数排序(升序) */
        public static void RadixSortAscending(IList<int> array, int vectorX = 10, int vectorY = 100)
        {
            if (array == null || array.Count < 2)
            {
                return;
            }

            for (int i = 0; i < vectorX; i++)
            {
                int[,] bucket = new int[vectorX, vectorY];
                foreach (var pivot in array)
                {
                    var position = (pivot / (int)Math.Pow(10, i)) % 10;
                    for (int l = 0; l < vectorY; l++)
                    {
                        if (bucket[position, l] == 0)
                        {
                            bucket[position, l] = pivot;
                            break;
                        }
                    }
                }

                for (int o = 0, x = 0; x < vectorX; x++)
                {
                    for (int y = 0; y < vectorY; y++)
                    {
                        if (bucket[x, y] == 0)
                        {
                            continue;
                        }
                        array[o++] = bucket[x, y];
                    }
                }
            }
        }

        /* 基数排序(倒序) */
        public static void RadixSortDescending(IList<int> array, int vectorX = 10, int vectorY = 100)
        {
            if (array == null || array.Count < 2)
            {
                return;
            }

            RadixSortAscending(array, vectorX, vectorY);
            for (int i = 0, j = array.Count - 1; i < j; i++, j--)
            {
                var pivot = array[i];
                array[i] = array[j];
                array[j] = pivot;
            }
        }

        /* 堆排序(小顶堆) */
        public static void HeapSortAscending<T>(IList<T> array)
            where T : IComparable<T>
        {
            if (array == null || array.Count < 2)
            {
                return;
            }

            void Heapify(IList<T> array, int length, int index)
            {
                var largestIndex = index;
                var leftChild = 2 * index + 1;
                var rightChild = 2 * index + 2;
                if (leftChild < length && array[leftChild].CompareTo(array[largestIndex]) > 0)
                {
                    largestIndex = leftChild;
                }

                if (rightChild < length && array[rightChild].CompareTo(array[largestIndex]) > 0)
                {
                    largestIndex = rightChild;
                }

                if (largestIndex != index)
                {
                    var pivot = array[index];
                    array[index] = array[largestIndex];
                    array[largestIndex] = pivot;
                    Heapify(array, length, largestIndex);
                }
            }

            var length = array.Count;
            for (var i = length / 2 - 1; i >= 0; i--)
            {
                Heapify(array, length, i);
            }

            for (var i = length - 1; i >= 0; i--)
            {
                var pivot = array[0];
                array[0] = array[i];
                array[i] = pivot;
                Heapify(array, i, 0);
            }
        }

        /* 堆排序(大顶堆) */
        public static void HeapSortDescending<T>(IList<T> array)
            where T : IComparable<T>
        {
            if (array == null || array.Count < 2)
            {
                return;
            }

            void Heapify(IList<T> array, int length, int index)
            {
                var largestIndex = index;
                var leftChild = 2 * index + 1;
                var rightChild = 2 * index + 2;
                if (leftChild < length && array[leftChild].CompareTo(array[largestIndex]) < 0)
                {
                    largestIndex = leftChild;
                }

                if (rightChild < length && array[rightChild].CompareTo(array[largestIndex]) < 0)
                {
                    largestIndex = rightChild;
                }

                if (largestIndex != index)
                {
                    var pivot = array[index];
                    array[index] = array[largestIndex];
                    array[largestIndex] = pivot;
                    Heapify(array, length, largestIndex);
                }
            }

            var length = array.Count;
            for (var i = length / 2 - 1; i >= 0; i--)
            {
                Heapify(array, length, i);
            }

            for (var i = length - 1; i >= 0; i--)
            {
                var pivot = array[0];
                array[0] = array[i];
                array[i] = pivot;
                Heapify(array, i, 0);
            }
        }

        /* 堆排序 */
        public static void HeapSort<T>(IList<T> array, bool ascending) /* O（N log N）*/
            where T : IComparable<T>
        {
            if (ascending)
            {
                HeapSortAscending(array);
            }
            else
            {
                HeapSortDescending(array);
            }
        }