快速排序和插入排序

快速排序和插入排序

两种排序的思想网上有很多，这里不过多叙述。接下来我提供两个算法在c#中的实现

两种方法放到脚本里可以直接用，不过需要自己写个单例类让类来继承。

然后就可以直接对数组或者集合来使用了。

   //给数组排序

    public class SortAlgorithm : Singleton<SortAlgorithm>
    {


        /*
         *   八大排序算法时间复杂度
         *   冒泡排序（o(n^2)）选择排序（o(n^2)）插入排序（o(n^2)）
         *   堆排序（o(nlogn)）归并排序（o(nlogn)）快速排序（o(nlogn)）
         *   希尔排序（o(n^1.25)）
         *   基数排序（o(n)）
         */


        #region 快速排序


        /// <summary>
        /// 快速排序（时间复杂度O(nlogn)）
        /// </summary>
        /// <param name="array">目标数组</param>
        public void QuickSort(int[] array)
        {
            int low = 0;
            int high = array.Length - 1;
            try
            {
                int keyValuePosition;


                if (low < high)
                {
                    keyValuePosition = keyValuePositionFunction(array, low, high);
                    QuickSort(array, low, keyValuePosition - 1);
                    QuickSort(array, keyValuePosition + 1, high);
                }
            }
            catch (System.Exception)
            {
                throw;
            }
        }


        /// <summary>
        /// 快速排序
        /// </summary>
        /// <param name="array">目标数组</param>
        /// <param name="low">起点索引</param>
        /// <param name="high">终点索引</param>
        public void QuickSort(int[] array, int low, int high)
        {
            try
            {
                int keyValuePosition;


                if (low < high)
                {
                    keyValuePosition = keyValuePositionFunction(array, low, high);
                    QuickSort(array, low, keyValuePosition - 1);
                    QuickSort(array, keyValuePosition + 1, high);
                }
            }
            catch (System.Exception)
            {
                throw;
            }
        }


        /// <summary>
        /// 快速排序（时间复杂度O(nlogn)）
        /// </summary>
        /// <param name="array">目标数组</param>
        public void QuickSort(List<int> list)
        {
            int[] array = list.ToArray();


            QuickSort(array);


            for (int i = 0; i < list.Count; i++)
            {
                list[i] = array[i];
            }
        }


        /// <summary>
        /// 快速排序
        /// </summary>
        /// <param name="array">目标数组</param>
        /// <param name="low">起点索引</param>
        /// <param name="high">终点索引</param>
        public void QuickSort(List<int> list, int low, int high)
        {
            int[] array = list.ToArray();


            QuickSort(array, low, high);


            for (int i = 0; i < list.Count; i++)
            {
                list[i] = array[i];
            }
        }


        /// <summary>
        /// 快排核心算法
        /// </summary>
        /// <param name="array">数组</param>
        /// <param name="low">起点</param>
        /// <param name="high">终点</param>
        /// <returns></returns>
        int keyValuePositionFunction(int[] array, int low, int high)
        {
            int leftIndex = low;
            int rightIndex = high;


            int keyValue = array[low];
            int temp;


            while (leftIndex < rightIndex)
            {
                while (leftIndex < rightIndex && array[leftIndex] <= keyValue)
                {
                    leftIndex++;
                }
                while (leftIndex < rightIndex && array[rightIndex] > keyValue)
                {
                    rightIndex--;
                }
                if (leftIndex < rightIndex)
                {
                    temp = array[leftIndex];
                    array[leftIndex] = array[rightIndex];
                    array[rightIndex] = temp;
                }
            }


            temp = keyValue;


            if (temp < array[rightIndex])
            {
                array[low] = array[rightIndex - 1];
                array[rightIndex - 1] = temp;
                return rightIndex - 1;
            }
            else
            {
                array[low] = array[rightIndex];
                array[rightIndex] = temp;
                return rightIndex;
            }
        }


        #endregion


        #region 插入排序


        /// <summary>
        /// 插入排序（时间复杂度O(n^2)）
        /// </summary>
        /// <param name="list">目标集合</param>
        public void InsertSort(List<int> list)
        {
            int key = 0;
            int j = 0;


            for (int i = 1; i < list.Count; i++)
            {
                key = list[i];
                for (j = i - 1; j >= 0; j--)
                {
                    if (list[j] <= key)
                        break;
                    else
                        list[j + 1] = list[j];
                }
                list[j + 1] = key;
            }
        }


        /// <summary>
        /// 插入排序（时间复杂度O(n^2)）
        /// </summary>
        /// <param name="list">目标数组</param>
        public void InsertSort(int[] array)
        {
            List<int> list = new List<int>(array);


            InsertSort(list);


            for (int i = 0; i < array.Length; i++)
            {
                array[i] = list[i];
            }
        }


        #endregion


    }