排序算法--交换排序（冒泡排序、快速排序、随机快速排序）java实现

package sortAlgorithms;
/*
* @author x@j
* @date 2013-10-01
* @content BubbleSort
* 冒泡排序的思想：假设有N个数据需要排序，则从第0个数开始，依次比较第0和第1个数据，如果第0个大于第1个则两者交换，否则什么动作都不做，继续比较第1个第2个…，这样依次类推，直至所有数据都“冒泡”到数据顶
* 复杂度：冒泡排序的效率O（N*N），比较N*N/2，交换N*N/4；
* */
public class BubbleSort<E extends Comparable<E>> extends Sort<E> {
public static void main(String[] args) {
BubbleSort<Integer> is=new BubbleSort<Integer>();
Integer[] a={49,38,65,97,76,13,27,49};
is.sort(a);
}
@Override
public void sort(E[] a, int p, int q) {
System.out.print("Bubble sort 初始序列为");
printArray(a);
for(int i=q;i>p+1;i--){
System.out.println("第 "+(a.length-i)+"趟排序结果为");
for(int j=p;j<i;j++){
if(a[j].compareTo(a[j+1])>0){
swap(a,j,j+1);
}
printArray(a);
}
}
}
}
/*
Bubble sort 初始序列为 49 38 65 97 76 13 27 49
第 1趟排序结果为
38 49 65 97 76 13 27 49
38 49 65 97 76 13 27 49
38 49 65 97 76 13 27 49
38 49 65 76 97 13 27 49
38 49 65 76 13 97 27 49
38 49 65 76 13 27 97 49
38 49 65 76 13 27 49 97
第 2趟排序结果为
38 49 65 76 13 27 49 97
38 49 65 76 13 27 49 97
38 49 65 76 13 27 49 97
38 49 65 13 76 27 49 97
38 49 65 13 27 76 49 97
38 49 65 13 27 49 76 97
第 3趟排序结果为
38 49 65 13 27 49 76 97
38 49 65 13 27 49 76 97
38 49 13 65 27 49 76 97
38 49 13 27 65 49 76 97
38 49 13 27 49 65 76 97
第 4趟排序结果为
38 49 13 27 49 65 76 97
38 13 49 27 49 65 76 97
38 13 27 49 49 65 76 97
38 13 27 49 49 65 76 97
第 5趟排序结果为
13 38 27 49 49 65 76 97
13 27 38 49 49 65 76 97
13 27 38 49 49 65 76 97
第 6趟排序结果为
13 27 38 49 49 65 76 97
13 27 38 49 49 65 76 97
*/

package sortAlgorithms;
/*
* @author x@j
* @date 2013-10-01
* @content QuickSort
* 快速排序(Quick Sort)的基本思想是：通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。
*
* */
public class QuickSort<E extends Comparable<E>> extends Sort<E> {
public static void main(String[] args) {
QuickSort<Integer> is=new QuickSort<Integer>();
Integer[] a={49,38,65,97,76,13,27,49};
is.sort(a);
}
@Override
public void sort(E[] a, int p, int q) {
printArray(a);
if(p<q){
int m=partition(a,p,q);
System.out.println("m="+m);
printArray(a);
sort(a,p,m-1);
sort(a,m+1,q);
}
}
public  int partition(E[] a,int p,int q){
E x=a[q];
int i=p-1;
for(int j=p;j<q;j++){
if(a[j].compareTo(x)<=0){
i++;
swap(a,i,j);
}
}
swap(a,i+1,q);
return i+1;
}

}
/*
* 49 38 65 97 76 13 27 49
m=4
49 38 13 27 49 65 97 76
49 38 13 27 49 65 97 76
m=1
13 27 49 38 49 65 97 76
13 27 49 38 49 65 97 76
13 27 49 38 49 65 97 76
m=2
13 27 38 49 49 65 97 76
13 27 38 49 49 65 97 76
13 27 38 49 49 65 97 76
13 27 38 49 49 65 97 76
m=6
13 27 38 49 49 65 76 97
13 27 38 49 49 65 76 97
13 27 38 49 49 65 76 97
*/

package sortAlgorithms;

import java.util.Random;

/*
* @author x@j
* @date 2013-10-01
* @content RandomQuickSort
* 相比快速排序，每次选择的比较参考点是随机的
*
* */
public class RandomQuickSort<E extends Comparable<E>> extends Sort<E> {
public static void main(String[] args) {
RandomQuickSort<Integer> is=new RandomQuickSort<Integer>();
Integer[] a={49,38,65,97,76,13,27,49};
is.sort(a);
}
@Override
public void sort(E[] a, int p, int q) {
printArray(a);
if(p<q){
int m=randomizedPartition(a,p,q);
System.out.println("m="+m);
printArray(a);
sort(a,p,m-1);
sort(a,m+1,q);
}
}
public int randomizedPartition(E[] a,int p,int q){
Random rand=new Random();
int m=p+rand.nextInt(q-p);
swap(a,m,q);
return partition(a, p, q);
}
public  int partition(E[] a,int p,int q){
E x=a[q];
int i=p-1;
for(int j=p;j<q;j++){
if(a[j].compareTo(x)<=0){
i++;
swap(a,i,j);
}
}
swap(a,i+1,q);
return i+1;
}

}
/*
* 49 38 65 97 76 13 27 49
m=5
49 38 49 13 27 65 76 97
49 38 49 13 27 65 76 97
m=0
13 38 49 27 49 65 76 97
13 38 49 27 49 65 76 97
13 38 49 27 49 65 76 97
m=2
13 27 38 49 49 65 76 97
13 27 38 49 49 65 76 97
13 27 38 49 49 65 76 97
m=4
13 27 38 49 49 65 76 97
13 27 38 49 49 65 76 97
13 27 38 49 49 65 76 97
13 27 38 49 49 65 76 97
m=6
13 27 38 49 49 65 76 97
13 27 38 49 49 65 76 97
13 27 38 49 49 65 76 97
*/