常见排序算法的实现和比较

    class Program
    {

        static void Main(string[] args)
        {
            int[] arr = new int[] { 2, 4, 1, 7, 4, 9, 6, 0, 1, 5, 8, 3 };
            List<int> list = MergeSort(arr.ToList<int>());

            foreach (int num in list)
                Console.WriteLine(num);
        }


        /// <summary>
        /// 7.
        /// 堆排序
        /// 不稳定
        /// nlogn
        /// </summary>
        public static void HeapSort(int[] arr)
        {
            if (arr == null || arr.Length < 1)
                return;

            //构建堆
            for (int i = arr.Length / 2; i >= 0; i--)
            {
                AdjustHeap(arr, i, arr.Length);
            }

            //堆排序
            for (int i = arr.Length - 1; i > 0; i--)
            {
                Swap(arr, 0, i);
                AdjustHeap(arr, 0,i);
            }
        }

        /// <summary>
        /// 调整大根堆
        /// </summary>
        public static void AdjustHeap(int[] arr,int index,int len)
        {
            int left = index * 2 + 1;
            int right = index * 2 + 2;
            int large = index;

            if(left< len && arr[left]>arr[large])
                large = left;

            if (right < len && arr[right] > arr[large])
                large = right;

            if (large != index)
            {
                Swap(arr, large, index);
                AdjustHeap(arr, large, len);
            }
        }

        /// <summary>
        /// 6.
        /// 归并排序
        /// 稳定
        /// nlogn
        /// </summary>
        public static List<int> MergeSort(List<int> list)
        {
            if (list == null || list.Count <= 1)
                return list;

            List<int> left = new List<int>();
            List<int> right = new List<int>();

            int mid = list.Count / 2;

            for (int i = 0; i < mid; i++)
                left.Add(list[i]);

            for (int i = mid; i < list.Count; i++)
                right.Add(list[i]);

            left = MergeSort(left);
            right = MergeSort(right);

            return Merge(left, right);
        }

        public static List<int> Merge(List<int> left,List<int> right)
        {
            int lenL = left.Count;
            int lenR = right.Count;
            List<int> rs = new List<int>();

            while (left.Count > 0 && right.Count > 0)
            {
                if (left[0] < right[0])
                {
                    rs.Add(left[0]);
                    left.RemoveAt(0);
                }
                else
                {
                    rs.Add(right[0]);
                    right.RemoveAt(0);
                }
            }

            rs.AddRange(right.Count > 0 ? right : left);

            return rs;
        }

        /// <summary>
        /// 5.
        /// 希尔排序
        /// 不稳定
        /// nlogn
        /// </summary>
        public static void ShellSort(int[] arr)
        {
            if (arr == null || arr.Length < 1)
                return;

            int gap = arr.Length / 2;

            for (; gap > 0; gap /= 2)
            {
                for (int i = gap; i < arr.Length; i++)
                {
                    int j = i;
                    int temp = arr[i];

                    while (j-gap >= 0 && arr[j - gap] > temp)
                    {
                        arr[j] = arr[j - gap];
                        j -= gap;
                    }

                    arr[j] = temp;
                }
            }
        }

        /// <summary>
        /// 4.
        /// 快速排序
        /// 不稳定
        /// nlogn
        /// </summary>
        public static void QuickSort(int[] arr,int start,int end)
        {
            if (arr == null || arr.Length < 1 || start>=end)
                return;

            int mid = Partition(arr, start, end);

            QuickSort(arr, start, mid - 1);
            QuickSort(arr, mid + 1, end);
        }

        /// <summary>
        /// Partition方法
        /// </summary>
        public static int Partition(int[] arr, int start, int end)
        {
            int key = arr[start];

            while (start < end)
            {
                while (start < end && arr[end] >= key)
                    end--;
                arr[start] = arr[end];

                while (start < end && arr[start] <= key)
                    start++;
                arr[end] = arr[start];
            }

            arr[start] = key;

            return start;
        }

        /// <summary>
        /// 3.
        /// 选择排序
        /// 不稳定
        /// n^2
        /// </summary>
        public static void SelectionSort(int[] arr)
        {
            if (arr == null || arr.Length < 1)
                return;

            for (int i = 0; i < arr.Length - 1; i++)
            {
                int maxIndex = i;

                for (int j = i + 1; j < arr.Length; j++)
                {
                    maxIndex = arr[j] < arr[maxIndex] ? j : maxIndex;
                }

                Swap(arr, i, maxIndex);
            }
        }

        /// <summary>
        /// 2.
        /// 插入排序
        /// 稳定
        /// n^2
        /// </summary>
        public static void InsertSort(int[] arr)
        {
            if (arr == null || arr.Length < 1)
                return;

            for (int i = 1; i < arr.Length; i++)
            {
                for (int j = i - 1; j >= 0; j--)
                {
                    if (arr[j] > arr[j + 1])
                        Swap(arr, j, j + 1);
                    else
                        break;
                }
            }
        }

        /// <summary>
        /// 1.
        /// 冒泡排序
        /// 稳定
        /// n^2
        /// </summary>
        public static void BubbleSort(int[] arr)
        {
            if (arr == null || arr.Length < 1)
                return;

            for (int i = 0; i < arr.Length; i++)
            {
                bool flag = true;

                for (int j = 0; j < arr.Length - i - 1; j++)
                {
                    if (arr[j] > arr[j + 1])
                    {
                        flag = false;
                        Swap(arr, j, j + 1);
                    }
                }

                if (flag) return;
            }
        }

        /// <summary>
        /// 交换数组中的两个数
        /// </summary>
        public static void Swap(int[] arr, int indexA, int indexB)
        {
            int temp = arr[indexA];
            arr[indexA] = arr[indexB];
            arr[indexB] = temp;
        }
    }