java简单实现冒泡 快速 选择排序

package com.排序;

public class 冒泡排序 {

/*
 *  冒泡排序，就是将第一个记录的值和第二个记录的值进行比较
 *  如果，前面的值比后面的值大，则交换位置
 *  反之，则不交换位置
 *  这样经过这样的一趟后，最大的值排在了最后面。所以下次循环的时候，可以少循环一次。 
 * */

private static void maopao(Integer [] a){
    //long starttime = System.currentTimeMillis();
    if(a.length > 0){
        for(int j=0; j<a.length-1; j++){
            for (int i=0; i < a.length-j-1/* a.length=6*/; i++){
                if(a[i] > a[i+1])
                {
                    Integer tmp = a[i];
                    a[i] = a[i+1];
                    a[i+1] = tmp;
                }
            }
        }
    }
    //long endtime = System.currentTimeMillis();
    //System.out.println("冒泡："+(endtime-starttime));
}

/*
 * 快速排序
 * */
private static void QuickSort(Integer[] array,int start,int end) { 
    //long starttime = System.currentTimeMillis();
       if(start<end) { 
           int key=array[start];//初始化保存基元  
           //初始化i,j 
           int i=start;
           int j;
           for(j=start+1;j<=end;j++) {
             //如果此处元素小于基元，则把此元素和i+1处元素交换，并将i加1，如大于或等于基元则继续循环 
               if(array[j]<key)  { 
                   int temp=array[j]; 
                   array[j]=array[i+1]; 
                   array[i+1]=temp; 
                   i++; 
               } 

           } 
           array[start]=array[i];//交换i处元素和基元  
           array[i]=key; 
           QuickSort(array, start, i-1);//递归调用  
           QuickSort(array, i+1, end); 

       }
       //long endtime = System.currentTimeMillis();
       //System.out.println("排序："+(endtime-starttime));
}

/*
 * 选择排序(升序)
 * 首先选择数组的首元素a[0]，认为它是最小的
 * 再一一与其他的元素进行比较，第一趟就能得到该数组的最小值
 * 依次类推
 * 把每一趟获取的最小值，放在a[n-1]位置上。
 * 这样就是一个排完序的升序数组
 * */
public static void xuanzeSort(Integer [] a){

    for(int j=0; j<a.length-1; j++){
        int min = a[j];
        for(int i=j; i<a.length-1; i++){
            if(min > a[i+1]){
                min = a[i+1];

                //交换位置
                int tmp = a[i+1];
                a[i+1] = a[j];
                a[j] = tmp;
            }
        }
    }
}

/*
 * 选择排序(降序)
 * 首先选择数组的首元素a[0]，认为它是最大的
 * 再一一与其他的元素进行比较，第一趟就能得到该数组的最大值
 * 依次类推
 * 把每一趟获取的最大值，放在a[n-1]位置上。
 * 这样就是一个排完序的降序数组
 * */
public static void xuanzeSortdesc(Integer [] a){

    for(int j=0; j<a.length-1; j++){
        int min = a[j];
        for(int i=j; i<a.length-1; i++){
            if(min < a[i+1]){
                min = a[i+1];

                //交换位置
                int tmp = a[i+1];
                a[i+1] = a[j];
                a[j] = tmp;
            }
        }
    }
}

//测试
public static void main(String[] args) {
    Integer [] a = new Integer[]{5, 8, 9, 7, 2, 1, 6, 5, 4};

    //测试冒泡
    maopao(a);
    for(int i=0; i<=a.length-1; i++){
        System.out.print(a[i]+" "); 
    }

    System.out.println("");

    //测试快速排序
    Integer [] b = new Integer[]{5, 8, 9, 7, 2, 1, 6, 5, 4};
    QuickSort(b, 0, b.length-1);
    for(int i=0; i<=b.length-1; i++){
        System.out.print(b[i]+" "); 
    }

    System.out.println("");

    //测试升序选择排序
    Integer [] c = new Integer[]{5, 8, 9, 7, 2, 1, 6, 5, 4};
    xuanzeSort(c);
    for(int i=0; i<=c.length-1; i++){
        System.out.print(c[i]+" "); 
    }

    System.out.println("");

    //测试降序选择排序
    Integer [] d = new Integer[]{5, 8, 9, 7, 2, 1, 6, 5, 4};
    xuanzeSortdesc(d);
    for(int i=0; i<=d.length-1; i++){
        System.out.print(d[i]+" "); 
    }
}

}