Java---快速排序与冒泡排序的比较

快速排序与冒泡排序的比较

经测试，快速排序循环次数明显比冒泡排序的少了很多

废话不多说，直接上代码

public class BubbleCompareQuick {

int array[] = { 49, 38, 65, 97, 76, 13, 27, 49, 78, 34, 12, 64, 5, 4, 62, 99, 98, 54, 56, 17, 18, 23, 34, 15, 35,25, 53, 51 };

int recycleTime = 0;

StringBuilder sb=new StringBuilder();

//快速排序
@Test
public void testQuick() {

quickSort(array, 0, array.length-1);
System.out.println("快速排序循环次数>>"+recycleTime);
System.out.println("=========================");
getResult(array);

}

//冒泡排序
@Test
public void testBubble() {
int tmp=0;
for(int i=0;i<array.length;i++){
for(int j=i;j<array.length;j++){
if(array[i]>array[j]){
tmp=array[i];
array[i]=array[j];
array[j]=tmp;
}
recycleTime++;
}
}
System.out.println("冒泡排序循环次数>>"+recycleTime);
System.out.println("=========================");
getResult(array);

}

public void quickSort(int array[],int left,int right){
if(left<right){
int middle=getMiddle(array, left, right);
quickSort(array, left, middle-1);
quickSort(array, middle+1, right);
}
}
public int getMiddle(int[] array,int left,int right){
int tmp=array[left];
while(left<right){
while(left<right && array[right]>=tmp){
right--;
recycleTime++;
}
array[left]=array[right];
while(left<right && array[left]<=tmp){
left++;
recycleTime++;
}
array[right]=array[left];
recycleTime++;
}
array[left]=tmp;

return left;

}

public  void getResult(int array[]){
int len=sb.length();
sb.delete(0, len);
sb.append("[");
for(int i=0;i<array.length;i++){
sb.append(array[i]+",");
}
sb.deleteCharAt(sb.length()-1);
sb.append("]");
System.out.println(sb.toString());

}
}

以Junit运行testBubble()

冒泡排序的结果：

冒泡排序循环次数>>406

[4,5,12,13,15,17,18,23,25,27,34,34,35,38,49,49,51,53,54,56,62,64,65,76,78,97,98,99]

以Junit运行testQuick()

快速排序的结果：

快速排序循环次数>>149

[4,5,12,13,15,17,18,23,25,27,34,34,35,38,49,49,51,53,54,56,62,64,65,76,78,97,98,99]

参考链接：http://www.cnblogs.com/qqzy168/archive/2013/08/03/3219201.html