各种内部排序算法，C#实现

     1、首先是插入排序，插入排序也有很多种，比如直接插入排序，二分插入排序等。但原理都基本差不多：在一个已经排好序的数列中插入新的信息。这样依次插入之后，整个数列就是一个有序的数列了。

 

插入排序

//插入排序

publicstaticint[] insertSort(int[] array)
{
for (int i =1; i < array.Length; i++) //遍历需要排序的数组
{
int j =0;
while (j < i && array[j] < array[i]) //找到满足条件的待插入数
{
j++;
}

int temp = array[i]; //保存待插入的数
int Last = i;

while (Last > j) //数组往后移动
{
array[Last] = array[Last -1];
Last--;
}
array[j] = temp; //把需要插入的数，插入到第j个位置
}
return array;
}

//插入排序

publicstaticint[] insertSort(int[] array)
{
for (int i =1; i < array.Length; i++) //遍历需要排序的数组
{
int j =0;
while (j < i && array[j] < array[i]) //找到满足条件的待插入数
{
j++;
}

int temp = array[i]; //保存待插入的数
int Last = i;

while (Last > j) //数组往后移动
{
array[Last] = array[Last -1];
Last--;
}
array[j] = temp; //把需要插入的数，插入到第j个位置
}
return array;
}

   

   2、冒泡排序，冒泡排序的基本原理是。比较旁边两个数字，（如果按升序排列）然后前面的数字比后面的数字大，则两个进行交换。

 

冒泡排序 

//冒泡排序
publicstaticint[] bubbleSort(int[] array)
{
for (int j =1; j < array.Length; j++) //排N次序
{
for (int i =1; i < array.Length; i++) //遍历一遍，第一次排序
{
if (array[i] < array[i -1]) //如果前面的比后面的大，则两者进行交换
{
int temp = array[i];
array[i] = array[i -1];
array[i -1] = temp;
}
}
}
return array;
}

   

   3、希尔排序，方法的基本思想是：先将整个待排元素序列分割成若干个子序列（由相隔某个“增量”的元素组成的）分别进行冒泡排序，然后依次缩减增量再进行排序，待整个序列中的元素基本有序（增量足够小）时，再对全体元素进行一次直接插入排序。

 

希尔排序 

//希尔排序
publicstaticint[] shellSort(int[] array)
{
ArrayList list = getDalt(array);
Int32[] dalt = (Int32[])list.ToArray(typeof(Int32)); //转换为数组
for (int i =0; i <dalt.Length; i++)
{
array = shellAdjust(array,dalt[i]);
}
return array;
}
//获得dalt数组,保存比较的增量表
publicstatic ArrayList getDalt(int[] array) {
ArrayList dalt =new ArrayList();
int i = (array.Length+1) /2;
while (i >1)
{
dalt.Add(i);
i =(i+1)/2;
}
dalt.Add(i);
return dalt;
}
//一趟排序
publicstaticint[] shellAdjust(int[] array, int add) //进行排序
{
int i=0;
while (i + add < array.Length)
{
if (array[i] > array[i + add]) //如果前面的比后面的大，则交换
{
int temp = array[i + add];
array[i+add]=array[i];
array[i] = temp;
}
i ++;
}
return array;
}

 

 

    4、快速排序。快速排序是对冒泡排序的一种改进。主要是通过把整个数列分成若干个小的数列再排序。 首先随便在数组中找到一个目标数，然后移动数组中的元素，使大于改数的移动右边，小于的则移动左边。这样就分成了两部分，一部分比该数大，一部分比该数小。然后通过递归的方式。进行全部排列。

   快速排序算法，最核心的就是中间的划分过程。但是上次这个过程并不能正确的划分出来。特此改正，造成误解，一并道歉。特此订正。

   

 1 public static int paration(Integer[] arrayList,int begin,int end){

 2         int temp=arrayList[begin];

 3         while (begin<end) {

 4             while (begin<end&&arrayList[end]>temp) {

 5                 end--;

 6             }

 7             if (begin<end) {

 8                 arrayList[begin]=arrayList[end];

 9                 begin++;

10             }

11             while (begin<end&&arrayList[begin]<temp) {

12                 begin++;

13             }

14             if (begin<end) {

15                 arrayList[end]=arrayList[begin];

16                 end--;

17             }

18         }

19         arrayList[begin]=temp;

20         return begin;

21     }

22     public static void quickSort(Integer[] arrayList,int begin,int end){

23         if(begin>=end)

24             return;

25         int par=paration(arrayList, begin, end);

26         if(begin<par-1)

27             quickSort(arrayList, begin, par-1);

28         if (par+1<end) 

29             quickSort(arrayList, par+1, end);

30         

31     }

 

 

 

 

    5、堆排序。堆排序首先需要建立一个堆。可以是大堆（父结点比子结点的元素都要大），也可以是小堆（父节点比子结点都要小）；本例建成大堆。

 

堆排序

// 堆排序
public static int [] heapSort( int [] array)
{
for ( int i = (array.Length - 1 ) / 2 ; i >= 0 ;i -- )
{
// 首先整个序列进行堆调整，
heapAdjust(array,i, array.Length);
}
for ( int i = array.Length - 1 ; i >= 0 ; i -- )
{
// 交换第一个和最后一个数据，形成排序
int temp = array[ 0 ];
array[ 0 ] = array[i];
array[i] = temp;
// 堆重新调整
heapAdjust(array, 0 ,i - 1 );
}
return array;
}

 

堆调整

///<summary>
/// 堆调整，建成一个大堆
///</summary>
///<param name="array"></param>
///<param name="i">开始调整</param>
///<param name="n">调整的长度</param>
///<returns>返回调整后的数组</returns>
publicstaticint[] heapAdjust(int[] array,int j,int n)
{
int temp = array[j]; //此次需要调整的数
for (int i = j*2+1; i < n; i=2*j+1)
{
if (i+1<n&&array[i] < array[i +1])
i++;
if (temp <array[i]) //如果孩子的结点更大，则交换
{
array[j] = array[i];
j = i;
}
else
break;
}
array[j] = temp; //需要调整的结点保存在适当位置
putOutArray(array);
return array;
}

  附录1：输出数组

 

输出数组

//输出数组
publicstaticvoid putOutArray(int[] array)
{
for (int i =0; i < array.Length; i++)
{
Console.Write(array[i] +"");
}
Console.Write("\n");
}

  附录2：测试数组

 

测试

staticvoid Main(string[] args)
{
int[] array = { 72, 45, 3, 64, 78, 12, 56, 76, 23, 46 };
Console.WriteLine("这是插入排序的结果");
putOutArray(insertSort(array));
Console.WriteLine("这是冒泡排序的结果");
putOutArray(bubbleSort(array));
Console.WriteLine("这是希尔排序的结果：");
putOutArray(shellSort(array));
Console.WriteLine("这是快速排序：");
putOutArray(quickSort(array,0,array.Length-1));
}

//快速排序
publicstaticint[] quickSort(int[] array,int low,int high)
{
int at;
if (low < high)
{
array = quick(array, low, high, out at); //把数组分成两个部分，
quickSort(array,low,at-1); //左边的排序
quickSort(array,at,high); //右边的排序
}
return array;
}
publicstaticint[] quick(int[] array, int first, int end,outint at) {
int mid = array[first]; //同第一个数比较
while (first <= end)
{
while (array[first] < mid) //向右移动，直到找到比mid大或相等的那个数
first++;
while (array[end] > mid) //向左移动，直到找到比Mid小的那个数
end--;
if (first <= end)
{
int temp = array[first]; //交换两个数
array[first] = array[end];
array[end] = temp;
first++;
end--;
}
}
at = first;
return array;
}

 

     版权所有，欢迎转载，但是转载请注明出处：潇一