排序算法之插入排序、希爾排序、歸併排序(C#)

插入排序

兩次for循環，外層從數組第二位i=1開始，內層for循環由i向前進行判斷，大於則將該位置與遍歷位置交換。此時注意，不能按i的位置獲取元素，應將該元素暫存，因爲交換時對應i位置元素值會變換。

c#代碼如下

		/// <summary>
        /// 插入排序
        /// </summary>
        /// <param name="array"></param>
        public int[] InsertSort(int[] array)
        {
            for (int i = 1; i < array.Length; i++)
            {
                int temp = array[i];
                for (int j = i - 1; j >= 0; j--)
                {
                    if (temp > array[j])
                    {
                        array[j + 1] = array[j];
                        array[j] = temp;
                    }
                    else
                    {
                        break;
                    }
                }
            }
            return array;
        }

希爾排序

希爾排序是插入的變種，插入排序比較的相鄰兩個元素，而希爾排序則是先將數組基本排序後，在進行相鄰遍歷。引用菜鳥教程的話是：

希爾排序的基本思想是：先將整個待排序的記錄序列分割成爲若干子序列分別進行直接插入排序，待整個序列中的記錄"基本有序"時，再對全體記錄進行依次直接插入排序。

C#代碼如下

		/// <summary>
        /// 希爾排序
        /// </summary>
        /// <param name="array"></param>
        /// <returns></returns>
        public int[] ShellSort(int[] array)
        {
            int gap = array.Length / 2;
            while (gap>=1)
            {
                for (int i = 0; i < array.Length; i++)
                {
                    for (int j = i + gap; j < array.Length && array[i] > array[j]; j+= gap)
                    {
                        int temp = array[i];
                        array[i] = array[j];
                        array[j] = temp;
                    }
                }
                gap /= 2;
            }
            return array;
        }

歸併排序

歸併排序使用的是遞歸，將數組分成左右兩個集合，遞歸直至左右集合只剩一個元素，將兩個元素排序後向上返回。

C#代碼如下

		/// <summary>
        /// 歸併排序
        /// </summary>
        /// <returns></returns>
        public int[] MergeSort(int[] array)
        {
            int length = array.Length;
            int half = length / 2;
            if (length <= 1)
            {
                return array;
            }
            //數組截取成左右兩個
            int[] left = array.Take(half).ToArray();
            int[] right = array.Skip(half).ToArray();
            //遞歸 直至分成 左右兩個只含一個元素時 排序後 向上返回
            left = MergeSort(left);
            right = MergeSort(right);
            return MergeSortDouble(left, right);
        }

        /// <summary>
        /// 對兩個數組排序後合併成一個返回
        /// </summary>
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// <returns></returns>
        public int[] MergeSortDouble(int[] left, int[] right)
        {
            List<int> li = new List<int>();
            int leftPositon = 0, rightPosition = 0;
            while (left.Count() > leftPositon && right.Count() > rightPosition)
            {
                if (left[leftPositon] > right[rightPosition])
                {
                    li.Add(right[rightPosition]);
                    rightPosition++;
                }
                else
                {
                    li.Add(left[leftPositon]);
                    leftPositon++;
                }
            }
            while (left.Count() > leftPositon)
            {
                li.Add(left[leftPositon]);
                leftPositon++;
            }
            while (right.Count() > rightPosition)
            {
                li.Add(right[rightPosition]);
                rightPosition++;
            }
            return li.ToArray();
        }