排序的几种算法

进行第四次交换后： 27       38  

一、插入排序(Insertion Sort)

  每次将一个待排序的数据元素，插入到前面已经排好序的数列中的适当位置，使数列依然有序；直到待排序数据元素全部插入完为止。

二、选择排序

　　每一趟从待排序的数据元素中选出最小（或最大）的一个元素，顺序放在已排好序的数列的最后，直到全部待排序的数据元素排完。

三、冒泡排序(BubbleSort)

　　两两比较待排序数据元素的大小，发现两个数据元素的次序相反时即进行交换，直到没有反序的数据元素为止。

四、快速排序（Quick Sort）

　　在当前无序区R[1..H]中任取一个数据元素作为比较的"基准"(不妨记为X)，用此基准将当前无序区划分为左右两个较小的无序区：R[1..I-1]和R[I+1..H]，且左边的无序子区中数据元素均小于等于基准元素，右边的无序子区中数据元素均大于等于基准元素，而基准X则位于最终排序的位置上，即R[1..I-1]≤X.Key≤R[I+1..H](1≤I≤H)，当R[1..I-1]和R[I+1..H]均非空时，分别对它们进行上述的划分过程，直至所有无序子区中的数据元素均已排序为止。

五、堆排序(Heap Sort)

  堆排序是一树形选择排序，在排序过程中，将R[1..N]看成是一颗完全二叉树的顺序存储结构，利用完全二叉树中双亲结点和孩子结点之间的内在关系来选择最小的元素。

2. 小结：

(1) 若n较小(n <= 50)，则可以采用直接插入排序或直接选择排序。由于直接插入排序所需的记录移动操作较直接选择排序多，因而当记录本身信息量较大时，用直接选择排序较好。

(2) 若文件的初始状态已按关键字基本有序，则选用直接插入或冒泡排序为宜。

(3) 若n较大，则应采用时间复杂度为O(nlog2n)的排序方法：快速排序、堆排序或归并排序。 快速排序是目前基于比较的内部排序法中被认为是最好的方法。

(4) 在基于比较排序方法中，每次比较两个关键字的大小之后，仅仅出现两种可能的转移，因此可以用一棵二叉树来描述比较判定过程，由此可以证明：当文件的n个关键字随机分布时，任何借助于"比较"的排序算法，至少需要O(nlog2n)的时间。

(5) 当记录本身信息量较大时，为避免耗费大量时间移动记录，可以用链表作为存储结构。

冒泡排序

using system；

namespace bubblesorter
{
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++；
}


}
}
public class mainclass
{
public static void main（）
{
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（）；
}
}
}


　　选择排序
　　
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；
}
int t=list[min]；
list[min]=list[i]；
list[i]=t；
}


}
}
public class mainclass
{
public static void main（）
{
int[] iarrary=new int[]{1,5,3,6,10,55,9,2,87,12,34,75,33,47}；
selectionsorter ss=new selectionsorter（）；
ss.sort（iarrary）；
for（int m=0；m＜iarrary.length；m++）
console.write（"{0} ",iarrary[m]）；
console.writeline（）；


}
}
}


　　插入排序

　　
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=new int[]{1,13,3,6,10,55,98,2,87,12,34,75,33,47}；
insertionsorter ii=new insertionsorter（）；
ii.sort（iarrary）；
for（int m=0；m＜iarrary.length；m++）
console.write（"{0}",iarrary[m]）；
console.writeline（）；
}
}
}


　　希尔排序

　　
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（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；
}
}
}
}
public class mainclass
{
public static void main（）
{
int[] iarrary=new int[]{1,5,13,6,10,55,99,2,87,12,34,75,33,47}；
shellsorter sh=new shellsorter（）；
sh.sort（iarrary）；
for（int m=0；m＜iarrary.length；m++）
console.write（"{0} ",iarrary[m]）；
console.writeline（）；
}
}
}