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
    }
}

 待续