C#排序算法大全

冒泡排序

描述：依次比较相邻的两个数，将小数放在前面，大数放在后面。即在第一趟：首先比较第1个和第2个数，将小数放前，大数放后。然后比较第2个数和第3个数，将小数放前，大数放后，如此继续，直至比较最后两个数，将小数放前，大数放后。至此第一趟结束，将最大的数放到了最后。在第二趟：仍从第一对数开始比较（因为可能由于第2个数和第3个数的交换，使得第1个数不再小于第2个数），将小数放前，大数放后，一直比较到倒数第二个数（倒数第一的位置上已经是最大的），第二趟结束，在倒数第二的位置上得到一个新的最大数（其实在整个数列中是第二大的数）。如此下去，重复以上过程，直至最终完成排序。由于在排序过程中总是小数往前放，大数往后放，相当于气泡往上升，所以称作冒泡排序。

using System;namespace BubbleSorter{       public class BubbleSorter       {              publicvoid 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++;                     }              }       }       publicclass MainClass       {               public static void Main()              {                     int[] iArrary=newint[]{1,5,13,6,10,55,99,2,87,12,34,75,33,47};                     BubbleSorter sh=newBubbleSorter();                     sh.Sort(iArrary);                     for(int m=0；m<iArrary.Length；m++)                     Console.Write("{0}",iArrary[m]);                      Console.WriteLine();              }       }}

快速排序

描述:快速排序（Quicksort）是对冒泡排序的一种改进。由C. A. R. Hoare在1962年提出。它的基本思想是：通过一趟排序将要排序的数据分隔成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。快速排序是不稳定的排序方法

namespace temp{　　publicclass QuickSort　　{　　///<summary>　　///排序　　///</summary>　　///<param name="numbers">；待排序数组</param>　　///<param name="left">；数组第一个元素索引Index</param>　　///<param name="right">；数组最后一个元素索引Index</param>　　privatestatic void Sort(int[] numbers,int left,int right)　　{　　//左边索引小于右边，则还未排序完成　　if(left < right)　　{　　//取中间的元素作为比较基准，小于他的往左边移，大于他的往右边移　　intmiddle = numbers[(left + right) / 2];　　inti = left - 1;　　intj = right + 1;　　while(true)　　{　　while(numbers[++i] < middle && i<right) ;　　while(numbers[--j] > middle && j>0) ;　　if(i >= j)　　break;　　Swap(numbers,i,j);　　}　　Sort(numbers,left,i- 1);　　Sort(numbers,j+ 1,right);　　}　　}　　///<summary>　　///交换元素值　　///</summary>　　///<param name="numbers">；数组</param>　　///<param name="i">；当前左边索引</param>　　///<param name="j">；当前右边索引</param>　　privatestatic void Swap(int[] numbers,int i,int j)　　{　　intnumber = numbers[i];　　numbers[i]= numbers[j];　　numbers[j]= number;　　}　　publicstatic void Main()　　{　　int[]max = { 6,5,2,9,7,4,0 };　　Sort(max,0,max.Length-1);　　StringBuildertemp =new StringBuilder();　　for(int i = 0; i < max.Length; i++)　　{　　temp.Append(max[i].ToString()+",");　　}　　Console.WriteLine(temp.ToString().Substring(0,temp.Length-1));　　Console.ReadLine();　　}　　}}

选择排序

描述：每一趟从待排序的数据元素中选出最小（或最大）的一个元素，顺序放在已排好序的数列的最后，直到全部待排序的数据元素排完。 选择排序是不稳定的排序方法

using System;namespace SelectionSorter{       public 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;                            }                            intt=list[min];                            list[min]=list[i];                            list[i]=t;                     }              }       }       public class MainClass       {               public static void Main()              {                     int[] iArrary=newint[]{1,5,3,6,10,55,9,2,87,12,34,75,33,47};                     SelectionSorterss=new SelectionSorter();                     ss.Sort(iArrary);                     for(int m=0;m<iArrary.Length;m++)                     Console.Write("{0}",iArrary[m]);                     Console.WriteLine();              }       }}

插入排序
描述：有一个已经有序的数据序列，要求在这个已经排好的数据序列中插入一个数，但要求插入后此数据序列仍然有序，这个时候就要用到一种新的排序方法——插入排序法,插入排序的基本操作就是将一个数据插入到已经排好序的有序数据中，从而得到一个新的、个数加一的有序数据，算法适用于少量数据的排序，时间复杂度为O(n^2)。是稳定的排序方法。插入算法把要排序的数组分成两部分：第一部分包含了这个数组的所有元素，但将最后一个元素除外，而第二部分就只包含这一个元素。在第一部分排序后，再把这个最后元素插入到此刻已是有序的第一部分里的位置。
包括：直接插入排序，二分插入排序（又称折半插入排序），链表插入排序，希尔排序（又称缩小增量排序）

using System;namespace InsertionSorter{       public 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;                     }              }       }       public class MainClass       {               public static void Main()              {                     int[] iArrary=newint[]{1,13,3,6,10,55,98,2,87,12,34,75,33,47};                     InsertionSorterii=new InsertionSorter();                     ii.Sort(iArrary);                     for(int m=0;m<iArrary.Length;m++)                     Console.Write("{0}",iArrary[m]);                     Console.WriteLine();              }       }}

希尔排序 
描述：希尔排序(Shell Sort)是插入排序的一种。是针对直接插入排序算法的改进。该方法又称缩小增量排序

using System;namespace ShellSorter{       public 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(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;                            }                     }              }       }       public class MainClass       {               public static void Main()              {                     int[] iArrary=newint[]{1,5,13,6,10,55,99,2,87,12,34,75,33,47};                     ShellSorter sh=newShellSorter();                     sh.Sort(iArrary);                     for(int m=0;m<iArrary.Length;m++)                     Console.Write("{0}",iArrary[m]);                     Console.WriteLine();              }       }}