package algorithm.sort;

import java.lang.reflect.Method;

import java.util.Arrays;

import java.util.Date;

/**

* Java常用排序算法及性能测试集合

*

* 本程序集合涵盖常用排序算法的编写，并在注释中配合极其简单的特例讲解了各种算法的工作原理，以方便理解和吸收；

* 程序编写过程中吸收了很多维基百科和别人blog上面的例子，并结合自己的思考，选择并改进一个最容易让人理解的写法

*(尤其是快速排序，我觉得我写的算法最好理解)。

* 同时包含一个集中式的性能测试和正确性测试方法，方便观测。

* @author /link.php?url=http://blog.csdn.net/sunxing007

* 转载请注明来自/link.php?url=http://blog.csdn.net/sunxing007

*/

public class SortUtil {

// 被测试的方法集合

static String[] methodNames = new String[]{

"bubbleSort",

"bubbleSortAdvanced",

"bubbleSortAdvanced2",

"selectSort",

"insertSort",

"insertSortAdvanced",

"insertSortAdvanced2",

"binaryTreeSort",

"shellSort",

"shellSortAdvanced",

"shellSortAdvanced2",

"mergeSort",

"quickSort",

"heapSort"

};

public static void main(String[] args) throws Exception{

//correctnessTest();

performanceTest(20000);

}

/**

* 正确性测试

* 简单地测试一下各个算法的正确性

* 只是为了方便观测新添加的算法是否基本正确；

* @throws Exception 主要是反射相关的Exception；

*/

public static void correctnessTest() throws Exception{

int len = 10;

int[] a = new int[len];

for(int i=0; i

for(int j=0; j

a[j] = (int)Math.floor(Math.random()*len*2);

}

Method sortMethod = null;

sortMethod = SortUtil.class.getDeclaredMethod(methodNames[i], a.getClass());

Object o = sortMethod.invoke(null, a);

System.out.print(methodNames[i] + " : ");

if(o==null){

System.out.println(Arrays.toString(a));

}

else{

//兼顾mergeSort，它的排序结果以返回值的形式出现；

System.out.println(Arrays.toString((int[])o));

}

}

}

/**

* 性能测试

* 数组长度用参数len传入，每个方法跑20遍取耗时平均值；

* @param len 数组长度 建议取10000以上，否则有些算法会显示耗时为0；

* @throws Exception 主要是反射相关的Exception；

*/

public static void performanceTest(int len) throws Exception{

int[] a = new int[len];

int times = 20;

System.out.println("Array length: " + a.length);

for(int i=0; i

Method sortMethod = null;

sortMethod = SortUtil.class.getDeclaredMethod(methodNames[i], a.getClass());

int totalTime = 0;

for(int j=0; j

for(int k=0; k

a[k] = (int)Math.floor(Math.random()*20000);

}

long start = new Date().getTime();

sortMethod.invoke(null, a);

long end = new Date().getTime();

totalTime +=(end-start);

}

System.out.println(methodNames[i] + " : " + (totalTime/times) + " ms");

//System.out.println(Arrays.toString(a));

}

}

/**

* 最原始的冒泡交换排序;

* 两层遍历，外层控制扫描的次数，内层控制比较的次数；

* 外层每扫描一次，就有一个最大的元素沉底；所以内层的比较次数将逐渐减小；

*/

public static void bubbleSort(int[] a){

for(int i=0; i

for(int j=0; j

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

int tmp = a[j];

a[j] = a[j+1];

a[j+1] = tmp;

}

}

}

}

/**

* 改进的冒泡法

* 改进之处在于：设一个标志位，如果某趟跑下来，没有发生交换，说明已经排好了；

*/

public static void bubbleSortAdvanced(int[] a){

int k = a.length-1;

boolean flag = true;

while(flag){

flag = false;

for(int i=0;i

if(a[i]>a[i+1]){

int tmp = a[i];

a[i] = a[i+1];

a[i+1] = tmp;

//有交换则继续保持标志位；

flag = true;

}

}

k--;

}

}

/**

* 改进的冒泡法2

* 改进之处在于吸收上面的思想(没有交换意味着已经有序)，如果局部的已经是有序的，则后续的比较就不需要再比较他们了。

* 比如：3142 5678，假如刚刚做完了2和4交换之后，发现这趟比较后续再也没有发生交换，则后续的比较只需要比到4即可；

* 该算法就是用一个标志位记录某趟最后发生比较的地点；

*/

public static void bubbleSortAdvanced2(int[] a){

int flag = a.length - 1;

int k;

while(flag>0){

k = flag;

flag = 0;

for(int i=0; i

if(a[i] > a[i+1]){

int tmp = a[i];

a[i] = a[i+1];

a[i+1] = tmp;

//有交换则记录该趟最后发生比较的地点；

flag = i+1;

}

}

}

}

/**

* 插入排序

*

* 关于插入排序，这里有几个约定，从而可以快速理解算法：

* i: 无序表遍历下标；i

* j: 有序表遍历下表；0<=j

* a[i]:表示当前被拿出来做插入排序的无序表头元素；

* a[j]:有序表中的任意元素；

*

* 算法关键点：把数组分割为a[0~i-1]有序表，a[i~n-1]无序表；每次从无序表头部取一个，

* 把它插入到有序表适当的位置，直到无序表为空；

* 初始时，a[0]为有序表，a[1~n-1]为无序表；

*/

public static void insertSort(int[] a){

//从无序表头开始遍历；

for(int i=1; i

int j;

//拿a[i]和有序表元素依次比较，找到一个恰当的位置；

for(j=i-1;j>=0; j--){

if(a[j] < a[i]){

break;

}

}

//如果找到恰当的位置，则从该位置开始，把元素朝后移动一格，为插入的元素腾出空间；

if(j!=(i-1)){

int tmp = a[i];

int k;

for(k = i-1; k>j;k--){

a[k+1] = a[k];

}

a[k+1] = tmp;

}

}

}

/**

* 改进的插入排序1

* 改进的关键在于：首先拿无序表头元素a[i]和有序表尾a[i-1]比较，

* 如果a[i]

* 从有序表尾开始，把有序表里面比a[i]大的元素都朝后移动，直到找到恰当的位置；

*/

public static void insertSortAdvanced(int[] a){

//遍历无序表；

for(int i=1; i

//如果无序表头元素小于有序表尾，说明需要调整；

if(a[i]