C#中常见的几种数组排序实例

1、冒泡排序

冒泡是最常用的排序方法之一，它在第一次排序的时候将每一条记录的关键字进行比较，直到n-1个记录和n个记录的关键字比较完成为止，再进行下一次排序，直到n-1趟记录为止

        class BubbleSorter
        /// 

        /// 冒泡排序
        /// 
        public void Sort(int[] list)
        {
            int i, j, temp;
            bool done = false;
            j = 1; while ((j < list.Length) && (!done))//判断长度
            {
                done = true;
                for (i = 0; i < list.Length - j; i++)
                {
                    if (list[i] > list[i + 1])
                    {
                        done = false;
                        temp = list[i];
                        list[i] = list[i + 1];//交换数据 
                        list[i + 1] = temp;
                    }
                }
                j++;
            }
        } 

 

2、选择排序

选择排序的思路是：每趟在n个记录中选取关键字最小的那个作为有序序列的第一个记录，并且以1~(n-1)进行(n-1)趟选择操作

 class SelectionSorter
    {
        private int min;
        /// 

        /// 选择排序
        /// 
        public void Sort(int[] list)
        {
            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;
            }
        }
    }

3、插入排序

将数据放入有序序列当中，找到比要插入的数据大和小的两个数据，然后插入它们中间

 class InsertionSorter
    {
        /// 

        /// 插入排序
        /// 
        public void Sort(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;
            }
        }
    }

4、快速排序

通过选取一个关键数据（通常是选第一个记录），然后再将比它小的数据排在关键字的前面，比它大的数据排在后面，递归调用

     //交换数据
        private void swap(ref int l, ref int r)
        {
            int temp;//临时值
            temp = l;//记录前一个值
            l = r;//记录后一个值
            r = temp;//前后交换数据
        }

         private void Sort(int[] list, int row, int cell)
        {
            int pivot;//临时变量，用来存储最大值
            int l, r;//分别用来记录遍历到的索引和最大索引
            int mid;//中间索引
            if (cell <= row)//判断输入的值是否合法
                return;
            else if (cell == row + 1)//判断两个索引是否相邻
            {
                if (list[row] > list[cell])//判断前面的值是否大于后面的值
                    swap(ref list[row], ref list[cell]);//交换前后索引的值
                return;
            }
            mid = (row + cell) >> 1;//记录数组的中间索引
            pivot = list[mid];//初始化临时变量的值
            swap(ref list[row], ref list[mid]);//交换第一个值和中间值的索引顺序
            l = row + 1;//记录遍历到的索引值
            r = cell;//记录最大索引
            try
            {
                //使用do...while循环遍历数组，并比较前后值的大小
                do
                {

                    while (l <= r && list[l] < pivot)//判断遍历到的索引是否小于最大索引
                        l++;//索引值加1
                    while (list[r] >= pivot)//判断最大值是否大于等于记录的分支点
                        r--;//做大索引值减1
                    if (l < r)//如果当前遍历到的值小于最大值
                        swap(ref list[l], ref list[r]);//交换顺序

                } while (l < r);
                list[row] = list[r];//在最小索引处记录最小值
                list[r] = pivot;//在最大索引处记录最大值
                if (row + 1 < r)//判断最小索引是否小于最大索引
                    Sort(list, row, r - 1);//调用自身进行快速排序
                if (r + 1 < cell)//判断最大索引是否小于数组长度
                    Sort(list, r + 1, cell);//调用自身进行快速排序
            }
            catch { }
        }

5、希尔排序

先将有个待排序的序列分割成若干个小序列，然后分别进行插入排序，待整个序列基于有序时再将整个序列进行一次插入排序。

子序列分割不是简单的“段落分割”，而是将相隔某个“增量”的数组成一个子序列。

class ShellSorter
        {
            /// 

            /// 希尔排序
            /// 
            public void Sort(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;
                    }
                }
            }

        }