（1）执行时间

（2）存储空间

（3）编程工作

对于数据量较小的情形，（1）（2）差别不大，主要考虑（3）；而对于数据量大的，（1）为首要。

主要排序法有：

一、冒泡（Bubble）排序——相邻交换

二、选择排序——每次最小/大排在相应的位置

三、插入排序——将下一个插入已排好的序列中

四、壳（Shell）排序——缩小增量

五、归并排序

六、快速排序

七、堆排序

八、拓扑排序

一、冒泡（Bubble）排序

----------------------------------Code 从小到大排序n个数------------------------------------

void BubbleSortArray()

{

for(int i=1i<ni++)

{

for(int j=0i<n-ij++)

{

if(a[j]>a[j+1])//比较交换相邻元素

{

int temp

temp=a[j]a[j]=a[j+1]a[j+1]=temp

}

}

}

}

-------------------------------------------------Code------------------------------------------------

效率 O（n²）,适用于排序小列表。

二、选择排序

----------------------------------Code 从小到大排序n个数--------------------------------

void SelectSortArray()

{

int min_index

for(int i=0i<n-1i++)

{

min_index=i

for(int j=i+1j<nj++)//每次扫描选择最小项

if(arr[j]<arr[min_index]) min_index=j

if(min_index!=i)//找到最小项交换，即将这一项移到列表中的正确位置

{

int temp

temp=arr[i]arr[i]=arr[min_index]arr[min_index]=temp

}

}

}

-------------------------------------------------Code-----------------------------------------

效率O（n²），适用于排序小的列表。

三、插入排序

--------------------------------------------Code 从小到大排序n个数-------------------------------------

void InsertSortArray()

{

for(int i=1i<ni++)//循环从第二个数组元素开始，因为arr[0]作为最初已排序部分

{

int temp=arr[i]//temp标记为未排序第一个元素

int j=i-1

while (j>=0 &&arr[j]>temp)/*将temp与已排序元素从小到大比较，寻找temp应插入的位置*/

{

arr[j+1]=arr[j]

j--

}

arr[j+1]=temp

}

}

------------------------------Code--------------------------------------------------------------

最佳效率O（n）；最糟效率O（n²）与冒泡、选择相同，适用于排序小列表

若列表基本有序，则插入排序比冒泡、选择更有效率。

四、壳（Shell）排序——缩小增量排序

-------------------------------------Code 从小到大排序n个数-------------------------------------

void ShellSortArray()

{

for(int incr=3incr<0incr--)//增量递减，以增量3，2，1为例

{

for(int L=0L<(n-1)/incrL++)//重复分成的每个子列表

{

for(int i=L+incri<ni+=incr)//对每个子列表应用插入排序

{

int temp=arr[i]

int j=i-incr

while(j>=0&&arr[j]>temp)

{

arr[j+incr]=arr[j]

j-=incr

}

arr[j+incr]=temp

}

}

}

}

--------------------------------------Code-------------------------------------------

适用于排序小列表。

效率估计O（nlog2^n）~O（n^1.5），取决于增量值的最初大小。建议使用质数作为增量值，因为如果增量值是2的幂，则在下一个通道中会再次比较相同的元素。

壳（Shell）排序改进了插入排序，减少了比较的次数。是不稳定的排序，因为排序过程中元素可能会前后跳跃。

五、归并排序

----------------------------------------------Code 从小到大排序---------------------------------------

void MergeSort(int low,int high)

{

if(low>=high) return//每个子列表中剩下一个元素时停止

else int mid=(low+high)/2/*将列表划分成相等的两个子列表,若有奇数个元素，则在左边子列表大于右侧子列表*/

MergeSort(low,mid)//子列表进一步划分

MergeSort(mid+1,high)

int [] B=new int [high-low+1]//新建一个数组，用于存放归并的元素

for(int i=low,j=mid+1,k=lowi<=mid &&j<=highk++)/*两个子列表进行排序归并，直到两个子列表中的一个结束*/

{

if (arr[i]<=arr[j])

{

B[k]=arr[i]

I++

}

else

{ B[k]=arr[j]j++}

}

for( j<=highj++,k++)//如果第二个子列表中仍然有元素，则追加到新列表

B[k]=arr[j]

for( i<=midi++,k++)//如果在第一个子列表中仍然有元素，则追加到新列表中

B[k]=arr[i]

for(int z=0z<high-low+1z++)//将排序的数组B的 所有元素复制到原始数组arr中

arr[z]=B[z]

}

-----------------------------------------------------Code---------------------------------------------------

效率O（nlogn），归并的最佳、平均和最糟用例效率之间没有差异。

适用于排序大列表，基于分治法。

六、快速排序

------------------------------------Code--------------------------------------------

/*快速排序的算法思想：选定一个枢纽元素，对待排序序列进行分割，分割之后的序列一个部分小于枢纽元素，一个部分大于枢纽元素，再对这两个分割好的子序列进行上述的过程。*/ void swap(int a,int b){int tt =a a =b b =t }

int Partition(int [] arr,int low,int high)

{

int pivot=arr[low]//采用子序列的第一个元素作为枢纽元素

while (low <high)

{

//从后往前栽后半部分中寻找第一个小于枢纽元素的元素

while (low <high &&arr[high] >= pivot)

{

--high

}

//将这个比枢纽元素小的元素交换到前半部分

swap(arr[low], arr[high])

//从前往后在前半部分中寻找第一个大于枢纽元素的元素

while (low <high &&arr [low ]<=pivot )

{

++low

}

swap (arr [low ],arr [high ])//将这个枢纽元素大的元素交换到后半部分

}

return low //返回枢纽元素所在的位置

}

void QuickSort(int [] a,int low,int high)

{

if (low <high )

{

int n=Partition (a ,low ,high )

QuickSort (a ,low ,n )

QuickSort (a ,n +1,high )

}

}

----------------------------------------Code-------------------------------------

平均效率O（nlogn），适用于排序大列表。

此算法的总时间取决于枢纽值的位置；选择第一个元素作为枢纽，可能导致O（n²）的最糟用例效率。若数基本有序，效率反而最差。选项中间值作为枢纽，效率是O（nlogn）。

基于分治法。

七、堆排序

最大堆：后者任一非终端节点的关键字均大于或等于它的左、右孩子的关键字，此时位于堆顶的节点的关键字是整个序列中最大的。

思想：

(1)令i=l,并令temp＝ kl

(2)计算i的左孩子j=2i+1

(3)若j<＝n－1，则转(4),否则转(6)

(4)比较kj和kj+1,若kj+1>kj,则令j＝j＋1，否则j不变；

(5)比较temp和kj，若kj>temp，则令ki等于kj，并令i=j,j=2i+1,并转(3),否则转(6)

(6)令ki等于temp，结束。

-----------------------------------------Code---------------------------

void HeapSort(SeqIAst R)

{ //对R[1..n]进行堆排序，不妨用R[0]做暂存单元int I BuildHeap(R)； //将R[1-n]建成初始堆for(i=ni>1；i--) //对当前无序区R[1..i]进行堆排序，共做n-1趟。{ R[0]=R[1]R[1]=R[i]R[i]=R[0]//将堆顶和堆中最后一个记录交换 Heapify(R,1,i-1) //将R[1..i-1]重新调整为堆，仅有R[1]可能违反堆性质 }} ---------------------------------------Code--------------------------------------

堆排序的时间，主要由建立初始堆和反复重建堆这两部分的时间开销构成，它们均是通过调用Heapify实现的。

堆排序的最坏时间复杂度为O(nlgn)。堆排序的平均性能较接近于最坏性能。 由于建初始堆所需的比较次数较多，所以堆排序不适宜于记录数较少的文件。 堆排序是就地排序，辅助空间为O(1)， 它是不稳定的排序方法。

堆排序与直接插入排序的区别:

直接选择排序中，为了从R[1..n]中选出关键字最小的记录，必须进行n-1次比较，然后在R[2..n]中选出关键字最小的记录，又需要做n-2次比较。事实上，后面的n-2次比较中，有许多比较可能在前面的n-1次比较中已经做过，但由于前一趟排序时未保留这些比较结果，所以后一趟排序时又重复执行了这些比较操作。

堆排序可通过树形结构保存部分比较结果，可减少比较次数。

八、拓扑排序

例 ：学生选修课排课先后顺序

拓扑排序：把有向图中各顶点按照它们相互之间的优先关系排列成一个线性序列的过程。

方法：

在有向图中选一个没有前驱的顶点且输出

从图中删除该顶点和所有以它为尾的弧

重复上述两步，直至全部顶点均已输出（拓扑排序成功），或者当图中不存在无前驱的顶点（图中有回路）为止。

---------------------------------------Code--------------------------------------

void TopologicalSort()/*输出拓扑排序函数。若G无回路，则输出G的顶点的一个拓扑序列并返回OK，否则返回ERROR*/

{

int indegree[M]

int i,k,j

char n

int count=0

Stack thestack

FindInDegree(G,indegree)//对各顶点求入度indegree[0....num]

InitStack(thestack)//初始化栈

for(i=0i<G.numi++)

Console.WriteLine("结点"+G.vertices[i].data+"的入度为"+indegree[i])

for(i=0i<G.numi++)

{

if(indegree[i]==0)

Push(thestack.vertices[i])

}

Console.Write("拓扑排序输出顺序为：")

while(thestack.Peek()!=null)

{

Pop(thestack.Peek())

j=locatevex(G,n)

if (j==-2)

{

Console.WriteLine("发生错误，程序结束。")

exit()

}

Console.Write(G.vertices[j].data)

count++

for(p=G.vertices[j].firstarcp!=NULLp=p.nextarc)

{

k=p.adjvex

if (!(--indegree[k]))

Push(G.vertices[k])

}

}

if (count<G.num)

Cosole.WriteLine("该图有环，出现错误，无法排序。")

else

Console.WriteLine("排序成功。")

}

----------------------------------------Code--------------------------------------

算法的时间复杂度O（n+e）。

已知一组无序数据a[1]、a[2]、……a[n]，需将其按升序排列。首先比较 a[1]与a[2]的值，若a[1]大于a[2]则交换两者的值，否则不变。再比较a[2]与a[3]的值，若a[2]大于a[3]则交换两者的值，否则不变。再比较a[3]与a[4]，以此类推，最后比较a[n-1]与a[n]的值。这样处理一轮后，a[n]的值一定是这组数据中最大的。再对 a[1]~a[n-1]以相同方法处理一轮，则a[n-1]的值一定是a[1]~a[n-1]中最大的。再对a[1]~a[n-2]以相同方法处理一轮，以此类推。共处理n-1轮后a[1]、a[2]、……a[n]就以升序排列了。

优点：稳定；

缺点：慢，每次只能移动相邻两个数据。

二、选择排序

冒泡排序的改进版。

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

选择排序是不稳定的排序方法。

n个记录的文件的直接选择排序可经过n-1趟直接选择排序得到有序结果：

①初始状态：无序区为R[1..n]，有序区为空。

②第1趟排序

在无序区R[1..n]中选出关键字最小的记录R[k]，将它与无序区的第1个记录R[1]交换，使R[1..1]和R[2..n]分别变为记录个数增加1个的新有序区和记录个数减少1个的新无序区。

……

③第i趟排序

第i趟排序开始时，当前有序区和无序区分别为R[1..i-1]和R(1≤i≤n- 1)。该趟排序从当前无序区中选出关键字最小的记录 R[k]，将它与无序区的第1个记录R交换，使R[1..i]和R分别变为记录个数增加1个的新有序区和记录个数减少1个的新无序区。

这样，n个记录的文件的直接选择排序可经过n-1趟直接选择排序得到有序结果。

优点：移动数据的次数已知（n-1次）；

缺点：比较次数多。

三、插入排序

已知一组升序排列数据a[1]、a[2]、……a[n]，一组无序数据b[1]、 b[2]、……b[m]，需将二者合并成一个升序数列。首先比较b[1]与a[1]的值，若b[1]大于a[1]，则跳过，比较b[1]与a[2]的值，若b[1]仍然大于a[2]，则继续跳过，直到b[1]小于a数组中某一数据a[x]，则将a[x]~a[n]分别向后移动一位，将b[1]插入到原来 a[x]的位置这就完成了b[1]的插入。b[2]~b[m]用相同方法插入。（若无数组a，可将b[1]当作n=1的数组a）

优点：稳定，快；

缺点：比较次数不一定，比较次数越少，插入点后的数据移动越多，特别是当数据总量庞大的时候，但用链表可以解决这个问题。

三、缩小增量排序

由希尔在1959年提出，又称希尔排序(shell排序)。

已知一组无序数据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。

优点：快，数据移动少；

缺点：不稳定，d的取值是多少，应取多少个不同的值，都无法确切知道，只能凭经验来取。

四、快速排序

快速排序是目前已知的最快的排序方法。

已知一组无序数据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] 两组数据进行快速排序。

优点：极快，数据移动少；

缺点：不稳定。

五、箱排序

已知一组无序正整数数据a[1]、a[2]、……a[n]，需将其按升序排列。首先定义一个数组x[m],且m>=a[1]、a[2]、……a[n]，接着循环n次，每次x[a]++.

优点：快，效率达到O(1)

缺点：数据范围必须为正整数并且比较小

六、归并排序

归并排序是多次将两个或两个以上的有序表合并成一个新的有序表。最简单的归并是直接将两个有序的子表合并成一个有序的表。

归并排序是稳定的排序.即相等的元素的顺序不会改变.如输入记录 1(1) 3(2) 2(3) 2(4) 5(5) (括号中是记录的关键字)时输出的 1(1) 2(3) 2(4) 3(2) 5(5) 中的2 和 2 是按输入的顺序.这对要排序数据包含多个信息而要按其中的某一个信息排序,要求其它信息尽量按输入的顺序排列时很重要.这也是它比快速排序优势的地方.

1 插入类排序

主要就是对于一个已经有序的序列中，插入一个新的记录。它包括：直接插入排序，折半插入排序和希尔排序

2 交换类排序

这类排序的核心就是每次比较都要“交换”，在每一趟排序都会两两发生一系列的“交换”排序，但是每一趟排序都会让一个记录排序到它的最终位置上。它包括：起泡排序，快速排序

3 选择类排序

每一趟排序都从一系列数据中选择一个最大或最小的记录，将它放置到第一个或最后一个为位置交换，只有在选择后才交换，比起交换类排序，减少了交换记录的时间。属于它的排序：简单选择排序，堆排序

4 归并类排序

将两个或两个以上的有序序列合并成一个新的序列

5 基数排序

主要基于多个关键字排序的。

下面针对上面所述的算法，讲解一些常用的java代码写的算法

二 插入类排序之直接插入排序

直接插入排序,一般对于已经有序的队列排序效果好。

基本思想：每趟将一个待排序的关键字按照大小插入到已经排序好的位置上。

算法思路，从后往前先找到要插入的位置，如果小于则就交换，将元素向后移动，将要插入数据插入该位置即可。时间复杂度为O(n2),空间复杂度为O(1)

package sort.algorithm

public class DirectInsertSort {

public static void main(String[] args) {

// TODO Auto-generated method stub

int data[] = { 2, 6, 10, 3, 9, 80, 1, 16, 27, 20 }

int temp, j

for (int i = 1i <data.lengthi++) {

temp = data[i]

j = i - 1

// 每次比较都是对于已经有序的

while (j >= 0 &&data[j] >temp) {

data[j + 1] = data[j]

j--

}

data[j + 1] = temp

}

// 输出排序好的数据

for (int k = 0k <data.lengthk++) {

System.out.print(data[k] + " ")

}

}

}

三 插入类排序之折半插入排序(二分法排序)

条件：在一个已经有序的队列中，插入一个新的元素

折半插入排序记录的比较次数与初始序列无关

思想：折半插入就是首先将队列中取最小位置low和最大位置high，然后算出中间位置mid

将中间位置mid与待插入的数据data进行比较，

如果mid大于data，则就表示插入的数据在mid的左边，high=mid-1

如果mid小于data，则就表示插入的数据在mid的右边,low=mid+1

最后整体进行右移操作。

时间复杂度O(n2),空间复杂度O(1)

package sort.algorithm

//折半插入排序

public class HalfInsertSort {

public static void main(String[] args) {

int data[] = { 2, 6, 10, 3, 9, 80, 1, 16, 27, 20 }

// 存放临时要插入的元素数据

int temp

int low, mid, high

for (int i = 1i <data.lengthi++) {

temp = data[i]

// 在待插入排序的序号之前进行折半插入

low = 0

high = i - 1

while (low <= high) {

mid = (low + high) / 2

if (temp <data[mid])

high = mid - 1

else

// low=high的时候也就是找到了要插入的位置，

// 此时进入循环中，将low加1，则就是要插入的位置了

low = mid + 1

}

// 找到了要插入的位置，从该位置一直到插入数据的位置之间数据向后移动

for (int j = ij >= low + 1j--)

data[j] = data[j - 1]

// low已经代表了要插入的位置了

data[low] = temp

}

for (int k = 0k <data.lengthk++) {

System.out.print(data[k] + " ")

}

}

}

四 插入类排序之希尔排序

希尔排序，也叫缩小增量排序，目的就是尽可能的减少交换次数，每一个组内最后都是有序的。

将待续按照某一种规则分为几个子序列，不断缩小规则，最后用一个直接插入排序合成

空间复杂度为O(1)，时间复杂度为O(nlog2n)

算法先将要排序的一组数按某个增量d（n/2,n为要排序数的个数）分成若干组，每组中记录的下标相差d.对每组中全部元素进行直接插入排序，然后再用一个较小的增量（d/2）对它进行分组，在每组中再进行直接插入排序。当增量减到1时，进行直接插入排序后，排序完成。

package sort.algorithm

public class ShellSort {

public static void main(String[] args) {

int a[] = { 1, 54, 6, 3, 78, 34, 12, 45, 56, 100 }

double d1 = a.length

int temp = 0

while (true)

{

//利用这个在将组内倍数减小

//这里依次为5,3,2,1

d1 = Math.ceil(d1 / 2)

//d为增量每个分组之间索引的增量

int d = (int) d1

//每个分组内部排序

for (int x = 0x <dx++)

{

//组内利用直接插入排序

for (int i = x + di <a.lengthi += d) {

int j = i - d

temp = a[i]

for (j >= 0 &&temp <a[j]j -= d) {

a[j + d] = a[j]

}

a[j + d] = temp

}

}

if (d == 1)

break

}

for (int i = 0i <a.lengthi++)

System.out.print(a[i]+" ")

}

}

五 交换类排序之冒泡排序

交换类排序核心就是每次比较都要进行交换

冒泡排序：是一种交换排序

每一趟比较相邻的元素，较若大小不同则就会发生交换，每一趟排序都能将一个元素放到它最终的位置！每一趟就进行比较。

时间复杂度O(n2)，空间复杂度O(1)

package sort.algorithm

//冒泡排序：是一种交换排序

public class BubbleSort {

// 按照递增顺序排序

public static void main(String[] args) {

// TODO Auto-generated method stub

int data[] = { 2, 6, 10, 3, 9, 80, 1, 16, 27, 20, 13, 100, 37, 16 }

int temp = 0

// 排序的比较趟数,每一趟都会将剩余最大数放在最后面

for (int i = 0i <data.length - 1i++) {

// 每一趟从开始进行比较，将该元素与其余的元素进行比较

for (int j = 0j <data.length - 1j++) {

if (data[j] >data[j + 1]) {

temp = data[j]

data[j] = data[j + 1]

data[j + 1] = temp

}

}

}

for (int i = 0i <data.lengthi++)

System.out.print(data[i] + " ")

}

}