几种常见的排序算法集锦

排序算法有很多,下面只是列举了几种常见的.

首先定义一个用于交换数组中2个值的方法

//用于交换的方法
public static void swap(Integer[] arr,int a,int b){
     int temp;
     temp = arr[a];
     arr[a] = arr[b];
     arr[b] = temp;
}

冒泡排序   O(n^2)

    public static void sort(Integer[] a){
        for (int i=0;i<a.length;i++) {

            Boolean flag = true;

            for (int j=a.length-2;j>=i;j--){

                if (a[j]>a[j+1]){
                    swap(a,j,j+1);
                    flag = false;
                }
            }

            if (flag){
                //数组已经有序
                return ;
            }
        }
    }

简单选择排序  O(n^2)

    public static void sort(Integer[] arr){

        for (int i=0;i<arr.length;i++){
            int min = i;
            for (int j=i+1;j<arr.length;j++){
                if (arr[j]<arr[min]){
                    min = j;
                }
            }
            if (min != i){
                swap(arr,i,min);
            }
        }

    }

直接插入排序  O(n^2)

    public static void sort(Integer[] arr){
        for(int i=1;i<arr.length;i++){
            if (arr[i]<arr[i-1]){
               int temp = arr[i];
               int j;
                for (j=i-1;j>=0 && arr[j]>temp;j--){
                    arr[j+1] = arr[j];
                }
                arr[j+1] = temp;
            }
        }
    }

希尔排序   O(nlog(n))~ O(n^2)   不稳定

    public static void sort(Integer arr[]){
        //增量,每次分组的间隔
        int increment = arr.length;
        //临时变量
        int temp;
        int j;
        while (increment>1){
            increment = increment / 3 +1;
            for (int i= 0;i<arr.length;i=i+increment){
                temp = arr[i];
                for (j=i-increment;j>=0&&arr[j]>temp;j=j-increment){
                    arr[j+increment] = arr[j];
                }
                arr[j+increment] = temp;
            }
        }
    }

快速排序    O(nlog(n))~ O(n^2)   不稳定

    public static void sort(Integer[] arr,int left,int right){
        int i,j,temp,t;
        if(left>right){
            return ;
        }
        i=left;
        j=right;
        //temp就是基准位
        temp = arr[left];
        while (i<j) {
            //先看右边，依次往左递减
            while (temp<=arr[j]&&i<j) {
                j--;
            }
            //再看左边，依次往右递增
            while (temp>=arr[i]&&i<j) {
                i++;
            }
            //如果满足条件则交换
            if (i<j) {
                t = arr[j];
                arr[j] = arr[i];
                arr[i] = t;
            }
        }
        //最后将基准为与i和j相等位置的数字交换
        arr[left] = arr[i];
        arr[i] = temp;
        //递归调用左半数组
        sort(arr, left, j-1);
        //递归调用右半数组
        sort(arr, j+1, right);
    }

用下面这段代码做测试,每个算法的大概时间(因个人电脑差异,数据可能有差异)

        Integer arr[] = new Integer[10000];
        for (int i =0;i<arr.length;i++){
            arr[i]= new Random().nextInt();
        }
        Long start = System.currentTimeMillis();
        sort(arr,0,arr.length-1);
        Long end = System.currentTimeMillis();
        System.out.println(start);
        System.out.println(end);
        System.out.println("运行时间为----"+(end-start));
        for (Integer i:arr) {
            System.out.print(i+" ");
        }

冒泡算法:430~550ms

简单选择排序:105~180ms

直接插入排序:55~80ms

希尔排序:40~60ms

快速排序:5~10ms