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]