C#八大排序算法

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace SortDemo
{
    class Program
    {
        static void Main(string[] args)
        {
            int[] iOriginalArray = new int[10] { 9, 5, 6, 1, 2, 3, 7, 4, 8, 10 };
            int[] iResultArray = new int[10];
            //iResultArray = BubbleSort(iOriginalArray);        //冒泡排序
            iResultArray = QuickSort(iOriginalArray, 0, iOriginalArray.Length - 1);       //快速排序
            //iResultArray = InsertSort(iOriginalArray);      //插入排序
            ShowResultArray(iResultArray);
            Console.ReadKey();
        }

        /// <summary>
        /// 輸出結果
        /// </summary>
        /// <param name="iResultArray"></param>
        static void ShowResultArray(int[] iResultArray)
        {
            for (int i = 0; i < iResultArray.Length; i++)
            {
                Console.Write(iResultArray[i] + " ");
            }
        }

        #region 冒泡排序
        /*
         * 已知一組無序數據a[1]、a[2]、……a[n]，需將其按升序排列。首先比較a[1]與a[2]的值，若a[1]大於a[2]則交換兩者的值，否則不變。
         * 再比較a[2]與a[3]的值，若a[2]大於a[3]則交換兩者的值，否則不變。再比較a[3]與a[4]，以此類推，最后比較a[n-1]與a[n]的值。
         * 這樣處理一輪后，a[n]的值一定是這組數據中最大的。再對a[1]~a[n-1]以相同方法處理一輪，則a[n-1]的值一定是a[1]~a[n-1]中最大的。
           * 再對a[1]~a[n-2]以相同方法處理一輪，以此類推。共處理n-1輪后a[1]、a[2]、……a[n]就以升序排列了。
          * 降序排列與升序排列相類似，若a[1]小於a[2]則交換兩者的值，否則不變，后面以此類推。 
            * 總的來講，每一輪排序后最大（或最小）的數將移動到數據序列的最后，理論上總共要進行n(n-1）/2次交換。
           * 優點：穩定
         * 時間復雜度：理想情況下（數組本來就是有序的），此時最好的時間復雜度為o(n),最壞的時間復雜度(數據反序的)，此時的時間復雜度為o(n*n) 。
          * 冒泡排序的平均時間負責度為o(n*n).
          * 缺點：慢，每次只移動相鄰的兩個元素。
          */
        /// <summary>
        /// 冒泡排序
        /// </summary>
        /// <param name="iOriginalArray"></param>
        /// <returns></returns>
        static int[] BubbleSort(int[] iOriginalArray)
        {
            int iTemp = 0;
            for (int i = 0; i < iOriginalArray.Length; i++)
            {
                for (int j = i + 1; j < iOriginalArray.Length; j++)
                {
                    if (iOriginalArray[i] > iOriginalArray[j])
                    {
                        iTemp = iOriginalArray[i];
                        iOriginalArray[i] = iOriginalArray[j];
                        iOriginalArray[j] = iTemp;
                    }
                }
            }
            return iOriginalArray;
        }
        #endregion

        #region 快速排序
        /// <summary>
        /// 快速排序
        /// </summary>
        /// <param name="iOriginalArray"></param>
        /// <param name="iLeft"></param>
        /// <param name="iRight"></param>
        /// <returns></returns>
        static int[] QuickSort(int[] iOriginalArray, int iLeft, int iRight)
        {
            if (iLeft < iRight)
            {
                int iMiddle = iOriginalArray[(iLeft + iRight) / 2];
                int i = iLeft - 1;
                int j = iRight + 1;
                while (true)
                {
                    while (iOriginalArray[++i] < iMiddle && i < iRight) ;
                    while (iOriginalArray[--j] > iMiddle && j > 0) ;
                    if (i >= j)
                    {
                        break;
                    }
                    int iTemp = iOriginalArray[i];
                    iOriginalArray[i] = iOriginalArray[j];
                    iOriginalArray[j] = iTemp;
                }
                QuickSort(iOriginalArray, iLeft, i - 1); 
                QuickSort(iOriginalArray, j + 1, iRight);
            }
            return iOriginalArray;
        }
        #endregion

        #region 插入排序
        /// <summary>
        /// 插入排序
        /// </summary>
        /// <param name="iOriginalArray"></param>
        /// <returns></returns>
        static int[] InsertSort(int[] iOriginalArray)
        {
            //與前一個數比較，所以下角標從1開始
            for (int i = 1; i < iOriginalArray.Length; i++)
            {
                //如果當前數比前一個數小，則開始置換
                if (iOriginalArray[i] < iOriginalArray[i - 1])
                {
                    //因為，當前小角標會被占用，所以先把需要置換的當前數存為一個臨時變量
                    int iTemp = iOriginalArray[i];
                    int j = 0;
                    for (j = i - 1; j >= 0 && iTemp < iOriginalArray[j]; j--)
                    {
                        //比較臨時變量是否小於j=[i-1]變量，如果小於，則把 j=[i-1]的值賦值給[j+1]=i變量。一直for循環到臨時變量大於j位置的數時，停止循環
                        iOriginalArray[j + 1] = iOriginalArray[j];
                    }
                    iOriginalArray[j + 1] = iTemp;      //最后把臨時變量放在對應的位置
                }
            }
            return iOriginalArray;
        }
        #endregion
    }
}

 待續