C#个人珍藏基础类库分享 — 9、基本排序算法类SortHelper

        做.NET开发的同学，一套简单易用的基础类库是必不可少的，这里把我混迹C#圈子十余载珍藏的类库分享出来，希望能够给刚踏入开发门槛的朋友一些帮助。

        后续会逐步分享基础库的其余部分，先列个大纲：

C#个人珍藏基础类库分享 — 1、通用缓存帮助类CacheHelper

C#个人珍藏基础类库分享 — 2、Memcached缓存帮助类MemcachedHelper

C#个人珍藏基础类库分享 — 3、目录、文件帮助类FileHelper

C#个人珍藏基础类库分享 — 4、字节数组帮助类BytesObjectHelper

C#个人珍藏基础类库分享 — 5、日志帮助类LogHelper

C#个人珍藏基础类库分享 — 6、数据库处理帮助类SqlHelper

C#个人珍藏基础类库分享 — 7、Xml处理帮助类XmlHelper

C#个人珍藏基础类库分享 — 8、通用工具帮助类ToolHelper

C#个人珍藏基础类库分享 — 9、基本排序算法类SortHelper

这里整理了以下排序算法：

1、冒泡排序法； 2、插入排序法； 3、选择排序法； 4、希尔排序法； 5、快速排序法

class SortHelper
    {
        /// <summary>
        /// 冒泡排序法
        /// </summary>
        /// <param name="list"></param>
        public static void BubbleSort(int[] list)
        {
            for (int i = 0; i < list.Length; i++)
            {
                for (int j = i; j < list.Length; j++)
                {
                    if (list[i] < list[j])
                    {
                        int temp = list[i];
                        list[i] = list[j];
                        list[j] = temp;
                    }
                }
            }
        }

        /// <summary>
        /// 插入排序法
        /// </summary>
        /// <param name="list"></param>
        public static void InsertionSort(int[] list)
        {
            for (int i = 1; i < list.Length; i++)
            {
                int t = list[i];
                int j = i;
                while ((j > 0) && (list[j - 1] > t))
                {
                    list[j] = list[j - 1];
                    --j;
                }
                list[j] = t;
            }

        }

        /// <summary>
        /// 选择排序法
        /// </summary>
        /// <param name="list"></param>
        public static void SelectionSort(int[] list)
        {
            int min;
            for (int i = 0; i < list.Length - 1; i++)
            {
                min = i;
                for (int j = i + 1; j < list.Length; j++)
                {
                    if (list[j] < list[min])
                        min = j;
                }
                int t = list[min];
                list[min] = list[i];
                list[i] = t;
            }

        }

        /// <summary>
        /// 希尔排序法
        /// </summary>
        /// <param name="list"></param>
        public static void ShellSort(int[] list)
        {
            int inc;
            for (inc = 1; inc <= list.Length / 9; inc = 3 * inc + 1) ;
            for (; inc > 0; inc /= 3)
            {
                for (int i = inc + 1; i <= list.Length; i += inc)
                {
                    int t = list[i - 1];
                    int j = i;
                    while ((j > inc) && (list[j - inc - 1] > t))
                    {
                        list[j - 1] = list[j - inc - 1];
                        j -= inc;
                    }
                    list[j - 1] = t;
                }
            }
        }

        private static void Swap(ref int l, ref int r)
        {
            int s;
            s = l;
            l = r;
            r = s;
        }

        /// <summary>
        /// 快速排序法
        /// </summary>
        /// <param name="list"></param>
        /// <param name="low"></param>
        /// <param name="high"></param>
        public static void QuickSort(int[] list, int low, int high)
        {
            int pivot;
            int l, r;
            int mid;
            if (high <= low)
            {
                return;
            }
            else if (high == low + 1)
            {
                if (list[low] > list[high])
                    Swap(ref list[low], ref list[high]);
                return;
            }
            mid = (low + high) >> 1;
            pivot = list[mid];
            Swap(ref list[low], ref list[mid]);
            l = low + 1;
            r = high;
            do
            {
                while (l <= r && list[l] < pivot)
                    l++;
                while (list[r] >= pivot)
                    r--;
                if (l < r)
                    Swap(ref list[l], ref list[r]);
            } while (l < r);
            list[low] = list[r];
            list[r] = pivot;
            if (low + 1 < r)
            {
                QuickSort(list, low, r - 1);
            }
            if (r + 1 < high)
            {
                QuickSort(list, r + 1, high);
            }
        }
    }

上述几个排序算法，在开发过程中很少用到，但是却是面试家常便饭，因为这几个算法是学习算法的过程必备的。

那么，既然都是排序算法，这几个算法究竟哪个效率高一点呢？

后面会专门出一篇文章来说明这个问题。