C#几种排序方法的整理[原]

     排序在学习基本语法和面试笔试中都是一个较为重要的知识点 查看了网上多种排序方法资料都不是很严格，某些思维上写的不是很清晰，这里将自己整理的几个写法帖出来 以资参考！

排序的相关理论，这里可以介绍一下以下几种典型的排序算法：
 

//冒泡排序：对一个队列里的数据，挨个进行轮询和交换，每次轮询出一个当前最大或者最小的值放在队尾，然后继续下次轮询，轮询长度-1，就跟冒泡一样，所以称为冒泡排序，运算时间复杂度N平方

//选择排序：对一个队列里的数据，选出当前最大或者最小的值，然后将他与队首的数据交换，然后从第二个开始，进行相同的操作，运算时间复杂度N平方，但由于他不像冒泡一样需要不停的交换位置，所以会比冒泡快一些

//插入排序：对一个队列里的数据，从第二个开始，与此位置之前的数据进行比较，形成局部有序的队列，循环此操作，直到队尾，运算时间复杂度依然为N平方，但他由于保证了局部的有序性，所以比较的次数会更少一些，相对前两种会更快

//希尔排序：其实就是用步长控制的插入排序，希尔排序通过加大插入排序中元素之间的间隔，并在这些有间隔的元素中进行插入排序，从而让数据项可以大幅度移动，这样的方式可以使每次移动之后的数据离他们在最终序列中的位置相差不大，保证数据的基本有序，大大提升了排序速度，运算时间复杂度N*logN

//快速排序：对一个队列，以他队尾的数据为基准值，先划分成两块数据，一块都大于这个值，一块小于这个值，然后对这两块进行同样的操作，这是最快的排序方法，运算时间复杂度N*logN

以上是几种典型排序算法的介绍 这里因为教学的原因只重点关注了冒泡排序算法和选择排序算法，如下：

先来看看冒泡排序算法，这里先帖一个同行的写法

Code
    class Program
    {
        static void Main(string[] args)
        {
            int[] iArrary = new int[] { 1, 5, 13, 6, 10, 55, 99, 2, 87, 12, 34, 75, 33, 47 };
            BubbleSorter sh = new BubbleSorter();
            sh.Sort(iArrary);
            for (int m = 0; m < iArrary.Length; m++)
            {
                Console.Write("{0} ", iArrary[m]);
                Console.WriteLine();
            }

        }
    }

    public 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++;
            }
        }

    }

 

看了许久后觉得这个写法思维还不算是最容易理解的，于是就写了自己的这个写法，参照如下：

Code
   class Program
    {
        static void Main(string[] args)
        {
            int[] array=new int[]{6,8,3,1,7,9,2,5,4};
            Program huashanlin=new Program();
            huashanlin.MaoPaoSort(array);
        }



        public void MaoPaoSort(int[] ary)
        {
            for (int k = 1; k < ary.Length; k++)
            {
                for (int i = 0; i < ary.Length - k; i++)
                {
                    if (ary[i] > ary[i + 1])
                    {
                        int temp;
                        temp = ary[i];
                        ary[i] = ary[i + 1];
                        ary[i + 1] = temp;
                    }
                }
            }
            for (int n = 0; n < ary.Length; n++)
            {
                Console.WriteLine(ary[n].ToString());
            }
        }

    }

 

下面看看选择排序算法，这个算法要简单一些，很容易理解，代码帖如下：

Code
    class Program
    {
        static void Main(string[] args)
        {
            int[] array = new int[] { 6, 8, 3, 1, 7, 9, 2, 5, 4 };
            Program huashanlin = new Program();
            huashanlin.XuanZeSort(array);
        }

        public void XuanZeSort(int[] arry)
        {
            for (int i = 0; i < arry.Length; i++)
            {
                for (int n = i + 1; n < arry.Length; n++)
                {
                    if (arry[i] > arry[n])
                    {
                        int temp;
                        temp = arry[i];
                        arry[i] = arry[n];
                        arry[n] = temp;
                    }
                }
            }
            for (int m = 0; m < arry.Length; m++)
            {
                Console.WriteLine(arry[m].ToString());
            }
        }

 
那么基本能掌握这两种算法后就可以看看以下的几个算法了，因为没时间自己敲一遍，这里就况且先贴出网友写的代码：

//插入法排序：

Code
    class Program
    {
        static void Main(string[] args)
        {
            int[] array = new int[] { 6, 8, 3, 1, 7, 9, 2, 5, 4 };
            Program huashanlin = new Program();
            huashanlin.InsertSort(array);
        }


        public void InsertSort(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;
            }
            for (int m = 0; m < list.Length; m++)
            {
                Console.WriteLine ("{0}", list[m]);
            }
        }
    }

 

 //希尔排序：

Code
    class Program
    {
        static void Main(string[] args)
        {
            int[] array = new int[] { 6, 8, 3, 1, 7, 9, 2, 5, 4 };
            Program huashanlin = new Program();
            huashanlin.ShellSort(array);
        }

        public 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;
                }
            }
            for (int m = 0; m < list.Length; m++)
            {
                Console.WriteLine("{0}", list[m]);
            }
        }

    }