java实现 冒泡排序 插入排序 选择排序

package test.sort;

public class TestSort {

    /**
     * 冒泡排序(升序)
     * 思想：将要排序的元素看做是竖着的排序的气泡，较小的元素比较轻，从而要往上符。在冒泡排序算法中我们要
     * 对这个气泡序列处理若干遍，所谓一遍处理，就是自底向上检查一遍这个序列。并时刻注意两个相邻的元素的顺序
     * 是否正确，如果发现两个相邻元素的顺序不对，即轻的元素子下面，就交互他们的位置，显然，处理一遍之后，最轻
     * 的元素就浮到最高位置，处理二遍之后，次轻的元素就浮到次高位置，在做第二编处理时，由于最高位置的元素已是
     * 最轻的元素，所以不必检查，一般地，第i编处理时，不必检查第i高位置以上的元素，应为前面i-1编的处理，他们
     * 正确的排好序。
     * @param src 待排序数组
     */
    private static void toBubbleSortAsc(int[] src){       
        long start = System.currentTimeMillis();
        for(int k=0;k<1000000;k++){
            for(int i=0;i<src.length;i++){
                for(int j=i+1;j<src.length;j++){
                    int temp;
                    if(src[i]>src[j]){
                        temp=src[j];
                        src[j]=src[i];
                        src[i]=temp;                   
                    }
                }
            }
        }
        System.out.println("冒泡排序(升序)如下,耗时:"+ (System.currentTimeMillis() - start));
    }
    /**
     * 冒泡排序(降序)
     * @param src 待排序数组
     */
    private static void toBubbleSortDesc(int[] src){       
       
        long start = System.currentTimeMillis();
        for(int k=0;k<1000000;k++){
            for(int i=0;i<src.length;i++){
                for(int j=i+1;j<src.length;j++){
                    int temp;
                    if(src[i]<src[j]){
                        temp=src[j];
                        src[j]=src[i];
                        src[i]=temp;                   
                    }
                }
            }
        }
        System.out.println("冒泡排序(降序)如下,耗时:"+ (System.currentTimeMillis() - start));
    }
    /**
     * 选择排序
     * 思想：对待排序的记录序列进行n-1编处理，第1编处理是将L[1..n]中最小者与L[1]交互位置第2编处理是将
     * L[2..n]中最小者与L[2]交换位置，...,第i编处理是将L[i..n]中最小者与L[i]交互位置，这样，经过i编处理
     * 后，前i个记录的位置就已经按从小到大顺序排序好了。
     * 当然，实际操作时，也可以根据需要，通过从待排序的记录中选择最大这与其首记录交互位置，按降序排序处理
     * @param src 待排序数组
     */
    private static void doChooseSort(int[] src){
        long start = System.currentTimeMillis();
        for(int k=0;k<1000000;k++){
            int temp;
            for(int i=0;i<src.length;i++){
                temp=src[i];
                //最小数下标
                int smallLocation=i;
                for(int j=i+1;j<src.length;j++){
                    if(src[j]<temp){
                        //取出最小数
                        temp=src[j];
                        //最小数下标
                        smallLocation=j;
                    }
                }
                src[smallLocation]=src[i];
                src[i]=temp;
            }
        }
        System.out.println("选择排序如下,耗时:"+ (System.currentTimeMillis() - start));
    }
   
    /**
     * 插入排序 (while循环)
     * @param src 待排序数组
     */
    private static void doInsertSortWhile(int[] src){
        long start = System.currentTimeMillis();
        for(int k=0;k<1000000;k++){
            for(int i=1;i<src.length;i++){
                int temp = src[i];
                int j=i;
                while(src[j-1]>temp){
                    src[j]=src[j-1];
                    j--;
                    if (j<=0) break;
                }
                src[j]=temp;
            }
        }
        System.out.println("插入排序 (while循环)如下,耗时:"+ (System.currentTimeMillis() - start));
    }
    /**
     * 插入排序 (for循环)
     * @param src 待排序数组
     */
    private static void doInsertSortfor(int[] src){
        long start = System.currentTimeMillis();
        for(int k=0;k<1000000;k++){
            for(int i=1;i<src.length;i++){
                int temp=src[i];
                int j;
                for (j=1;j>0;j--){
                    if(src[j-1]>temp){
                        src[j]=src[j-1];
                    }else{
                        break;
                    }
                }
                src[j]=temp;
            }
        }
        System.out.println("插入排序 (for 循环)如下,耗时:"+ (System.currentTimeMillis() - start));
    }
   
    public static void main(String[] args){
        int[] src=new int[]{3,5,1,2,7,8,4};
       
        //冒泡排序(升序)
        TestSort.toBubbleSortAsc(src);       
        for(int i=0;i<src.length;i++){
            System.out.print(src[i]+" ");           
        }
        //冒泡排序(降序)
        System.out.println();
        TestSort.toBubbleSortDesc(src);       
        for(int i=0;i<src.length;i++){
            System.out.print(src[i]+" ");           
        }
        //选择排序
        System.out.println();
        TestSort.doChooseSort(src);       
        for(int i=0;i<src.length;i++){
            System.out.print(src[i]+" ");           
        }
        //插入排序 (while循环)
        System.out.println();
        TestSort.doInsertSortWhile(src);       
        for(int i=0;i<src.length;i++){
            System.out.print(src[i]+" ");           
        }
        //插入排序 (for循环)
        System.out.println();
        TestSort.doInsertSortfor(src);       
        for(int i=0;i<src.length;i++){
            System.out.print(src[i]+" ");           
        }
       
    }
}