C#排序方法总结

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

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

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

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

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

冒泡排序：

原理：对一个数列，我们将它进行轮循和交换，每次轮循出最大数或最小数放在对尾，依次进行循环，轮循长度为-1。

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

选择排序：

原理：对一个数列，我们选出最大或最小的数，放在队尾，依次循环下去，循环长度为-1；由于没有冒泡排序那每次都要比较，因此比冒泡排序要快。

  publicstaticvoidSelectionSort(int[] list)
{
intmin;
for(inti =0; i <list.Length -1; i++)
{
min =i;
for(intj =i +1; j <list.Length; j++)
{
if(list[j] <list[min])
min =j;
}
intt =list[min];
list[min] =list[i];
list[i] =t;
}
}

插入排序：

    原理：对一个数列，我们从第二个数开始，将它与它前面的数字进行比较，每次选出最大

或最小的数放在队首，因而形成一个有序的队列，所以它比选择排序更快。

publicstaticvoidInsertionSort(int[] list)
{
for(inti =1; i <list.Length; i++)
{
intt =list[i];
intj =i;
while((j >0) &&(list[j -1] >t))
{
list[j] =list[j -1];
--j;
}
list[j] =t;
}
}

希尔排序法：

      原理：已知一组无序数据a[1]、a[2]、……a[n]，需将其按升序排列。发现当n不大是，插入排序的效果很好。首先取一增量d(d <n)，将a[1]、a[1+d]、a[1+2d]……列为第一组，a[2]、a[2+d]、a[2+2d]……列为第二组……，a[d]、a[2d]、a[3d]……列为最后一组依此类推，在各组内用插入排序，然后取d' <d，重复上述操作，直到d=1。

//// <summary>
///希尔排序法
///</summary>
///<param name="list"></param>
        publicstaticvoidShellSort(int[] list)
{
intinc;
for(inc =1; inc <=list.Length /9; inc =3*inc +1) ;
for(; inc >0; inc /=3)
{
for(inti =inc +1; i <=list.Length; i +=inc)
{
intt =list[i -1];
intj =i;
while((j >inc) &&(list[j -inc -1] >t))
{
list[j -1] =list[j -inc -1];
j -=inc;
}
list[j -1] =t;
}
}
}
privatestaticvoidSwap(refintl, refintr)
{
ints;
s =l;
l =r;
r =s;
}

快速排序法：

原理：已知一组无序数据a[1]、a[2]、……a[n]，需将其按升序排列。首先任取数据a[x]作为基准。比较a[x]与其它数据并排序，使a[x]排在数据的第k位，并且使a[1]~a[k-1]中的每一个数据 <a[x]，a[k+1]~a[n]中的每一个数据>a[x]，然后采用分治的策略分别对a[1]~a[k-1]和a[k+1]~a[n]两组数据进行快速排序。

///快速排序法
///</summary>
///<param name="list"></param>
///<param name="low"></param>
///<param name="high"></param>
         publicstaticvoidSort(int[] list, intlow, inthigh)
{
intpivot;
intl, r;
intmid;
if(high <=low)
return;
elseif(high ==low +1)
{
if(list[low] >list[high])
Swap(reflist[low], reflist[high]);
return;
}
mid =(low +high) >>1;
pivot =list[mid];
Swap(reflist[low], reflist[mid]);
l =low +1;
r =high;
do
{
while(l <=r &&list[l] <pivot)
l++;
while(list[r] >=pivot)
r--;
if(l <r)
Swap(reflist[l], reflist[r]);
} while(l <r);
list[low] =list[r];
list[r] =pivot;
if(low +1<r)
Sort(list, low, r -1);
if(r +1<high)
Sort(list, r +1, high);
}
}
}