【转】几种基本的排序算法演示

 package sort;
import java.sql.Timestamp;
import java.util.Arrays;
import java.util.Random;

public class Sort {
    static int NUM=100000;
    static long start;//开始时间
    static long end;//结束时间
    public static void main(String[] args) {
        //生成3个相同的数组，同一情况下比较
        Random random=new Random();
        int[]a1=new int[NUM];
        int[]a2=new int[NUM];
        int[]a3=new int[NUM];
        int[]a4=new int[NUM];
        for(int i=0;i<NUM;i++){
            a1[i]=random.nextInt(NUM);
            a2[i]=a3[3]=a4[i]=a1[i];
        }
   
//        int[]a2=Arrays.copyOf(a1, NUM);
//        int[]a3=Arrays.copyOf(a1, NUM);
//        int[]a4=Arrays.copyOf(a1, NUM);
       
        //排序算法比较，开始了...
        start=System.currentTimeMillis();
        System.out.println("冒泡排序开始时间："+new Timestamp(start));
        mpSort(a1);
        end=System.currentTimeMillis();
        System.out.println("冒泡排序结束时间："+new Timestamp(end));
        System.out.println("长度为"+NUM+"的数组冒泡排序耗时"+(end-start)+"ms!");
//        for(int i=0;i<a1.length;i++){
//            System.out.print(a1[i]+",");
//        }
        System.out.print("/n"+"---------------"+"/n");
       
        start=System.currentTimeMillis();
        System.out.println("选择排序开始时间："+new Timestamp(start));
        xzSort(a2);
        end=System.currentTimeMillis();
        System.out.println("选择排序结束时间："+new Timestamp(end));
        System.out.println("长度为"+NUM+"的数组选择排序耗时"+(end-start)+"ms!");
//        for(int i=0;i<a2.length;i++){
//            System.out.print(a2[i]+",");
//        }
        System.out.print("/n"+"---------------"+"/n");
       
        start=System.currentTimeMillis();
        System.out.println("插入排序开始时间："+new Timestamp(start));
        crSort(a3);
        end=System.currentTimeMillis();
        System.out.println("插入排序结束时间："+new Timestamp(end));
        System.out.println("长度为"+NUM+"的数组插入排序耗时"+(end-start)+"ms!");
//        for(int i=0;i<a3.length;i++){
//            System.out.print(a3[i]+",");
//        }
        System.out.print("/n"+"---------------"+"/n");
       
        start=System.currentTimeMillis();
        System.out.println("快速排序开始时间："+new Timestamp(start));
        quickSort(a4);
        end=System.currentTimeMillis();
        System.out.println("快速排序结束时间："+new Timestamp(end));
        System.out.println("长度为"+NUM+"的数组快速排序耗时"+(end-start)+"ms!");
//        for(int i=0;i<a4.length;i++){
//            System.out.print(a4[i]+",");
//        }
//        System.out.print("/n/n"+"---------------"+"/n");
    }
   
   
    //冒泡排序mpSort(int[])
    //比较:(n-1)+(n-2)+...+1次，最多交换(n-1)+(n-2)+...+1次
    //第1~n个,第1~n-1个,第1~n-2个...
    public static void mpSort(int[] data) {
        for (int i=0; i<data.length-1; i++) {
            for(int j=0;j<data.length-1-i;j++){
                if(data[j]>data[j+1]){
                    int temp = data[j];
                    data[j] = data[j+1];
                    data[j+1] = temp;    
                } 
            }
        }
    }
   
    //选择排序xzSort(int[])
    //比较(n-1)+(n-2)+...+1次，最多交换(n-1)次
    //第1~n个,第2~n个,第3~n个...
    public static void xzSort(int[] data) {
        for (int i=0; i<data.length-1; i++) {
            int k=i;
            for(int j=i+1;j<data.length;j++){
                if(data[k]>data[j]){
                   k=j;
                }
            }
            int temp=data[i];
            data[i]=data[k];
            data[k]=temp;
        }
    }
   
    //插入排序
    //比较第i趟后，使得前i个有序
    public static void crSort(int[] data) {
        for (int i=0; i<data.length; i++) {
            for (int j=0; j<i; j++) {
                if (data[i]<data[j]) {
                    int temp = data[i];
                    data[i] = data[j];
                    data[j] = temp;
                }
            }
        }
    }
   
    //快速排序qsSort(int[])//采用2分算法
    public static void quickSort(int[] array) {
        quickSort(array, 0, array.length - 1);
    }
    private static void quickSort(int[] array, int low, int high) {
        if (low < high) {
            int p = partition(array, low, high);
            quickSort(array, low, p - 1);
            quickSort(array, p + 1, high);
        }
    }
    private static int partition(int[] array, int low, int high) {
        int s = array[high];
        int i = low - 1;
        for (int j = low; j < high; j++) {
            if (array[j] < s) {
                i++;
                swap(array, i, j);
            }
        }
        swap(array, ++i, high);
        return i;
    }
    private static void swap(int[] array, int i, int j) {
        int temp;
        temp = array[i];
        array[i] = array[j];
        array[j] = temp;
    }
   
}

 

//结果

冒泡排序开始时间：2009-09-15 13:05:29.057
冒泡排序结束时间：2009-09-15 13:06:22.031
长度为100000的数组冒泡排序耗时52974ms!

---------------
选择排序开始时间：2009-09-15 13:06:22.031
选择排序结束时间：2009-09-15 13:06:53.927
长度为100000的数组选择排序耗时31896ms!

---------------
插入排序开始时间：2009-09-15 13:06:53.927
插入排序结束时间：2009-09-15 13:07:21.827
长度为100000的数组插入排序耗时27900ms!

---------------
快速排序开始时间：2009-09-15 13:07:21.827
快速排序结束时间：2009-09-15 13:07:21.874
长度为100000的数组快速排序耗时47ms!