冒泡，选择，插入，希尔，快排实现与20万数据的本地测试

实现代码如下：

package test;

import java.util.Arrays;

/**
 * @author chenxiang
 * @date 2019-09-12 23:30
 */
public class SortingFunction {

    public static void main(String[] args) {
        int[] arr = new int[20];
        for(int i = 0; i < 20; i++){
            arr[i] = (int)(Math.random()*20);
        }
        System.out.println(Arrays.toString(arr));
        long start = System.currentTimeMillis();
        //quickSort(arr,0,arr.length-1);//20万数据测试时间：0.072秒
        shellSort2(arr);//20万数据测试时间：0.046秒
        //bubbleSort(arr);//20万数据测试时间：69.187秒
        //selectSort(arr);//20万数据测试时间：18.433秒
        //insertSort(arr);//20万数据测试时间：3.91秒
        long end = System.currentTimeMillis();
        System.out.println("时间为："+((double)(end-start)/1000.0)+"秒");
        System.out.println(Arrays.toString(arr));

    }

    /*
    * 冒泡排序
    * */
    public static void bubbleSort (int[] arr){
        int len = arr.length;
        for(int i = 0; i < len - 1; i++){
            boolean flag = true;
            for(int j = 0; j < len - i - 1; j++){
                if(arr[j] > arr[j+1]){
                    flag = false;
                    int temp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = temp;
                }
            }
            if(flag)break;
        }
    }

    /*
    * 选择排序
    * */
    public static void selectSort (int[] arr) {
        int len = arr.length;
        for(int i = 0; i < len - 1; i++){
            int minIndex = i;
            for(int j = i + 1;j < len; j++){
                if(arr[minIndex] > arr[j]){
                    minIndex = j;
                }
            }
            int temp = arr[i];
            arr[i] = arr[minIndex];
            arr[minIndex] = temp;
        }
    }

    /*
    * 插入排序
    * */
    public static  void insertSort (int[] arr){
        for(int i = 1; i < arr.length; i++){
            //使用一个临时变量保存插入值
            int insertVal = arr[i];
            int insertIndex = i - 1;
            //找插入位置
            while(insertIndex >= 0 && arr[insertIndex] > insertVal){
                arr[insertIndex+1] = arr[insertIndex];
                insertIndex--;
            }
            arr[insertIndex+1] = insertVal;
        }
    }

    /*
    * 采用移动法（加入插入排序）的希尔排序
    * */
    public static void shellSort2 (int[] arr){
        int len = arr.length;
        for(int gap = len/2; gap > 0; gap /= 2){
            for(int i = gap; i < len; i++){
                //插入值
                int value = arr[i];
                //索引
                int index = i - gap;
                while(index >= 0 && arr[index] > value){
                    arr[index+gap] = arr[index];
                    index -= gap;
                }
                if(index != i - gap){
                    arr[index+gap] = value;
                }
            }
        }
    }

    /*
    * 采用交换法的希尔排序
    * */
    public static void shellSort (int[] arr){
        //将数据按照除以二的数据量进行分组
        int temp;
        int len = arr.length;
        for(int gap = len/2; gap > 0; gap/=2){
            for(int i = gap; i < len; i++){
                for(int j = i - gap; j >= 0; j-=gap){
                    if(arr[j+gap] < arr[j]){
                        temp = arr[j+gap];
                        arr[j+gap] = arr[j];
                        arr[j] = temp;
                    }
                }
            }
        }
    }

    /*
    * 快速排序
    * */
    public static void quickSort (int[] arr,int left,int right){
        //左下标
        int l = left;
        //右下标
        int r = right;
        //中轴值
        int pivot = arr[(left+right)/2];
        //临时变量
        int temp;
        while(l<r){
            //找到pivot左边一直找，直到找到大于等于pivot值才退出
            while(arr[l] < pivot){
                l += 1;
            }
            //找到pivot左边一直找，直到找到大于等于pivot值才退出
            while(arr[r] > pivot){
                r -= 1;
            }
            //如果l>r说明pivot的左右两边的值，左边全部是小于等pivot
            //右边全是大于等于pivot了
            if(l >= r){
                break;
            }
            //交换
            temp = arr[l];
            arr[l] = arr[r];
            arr[r] = temp;
            //交换完后发现arr[l] == pivot，前移
            if(arr[l] == pivot){
                r -= 1;
            }
            //交换完后发现arr[r] == pivot，后移
            if(arr[r] == pivot){
                l += 1;
            }
        }
        //如果l==r,必须l++,r--,否则会栈溢出
        if(l == r){
            l++;
            r--;
        }
        //向左递归
        if(left < r){
            quickSort(arr,left,r);
        }
        //向右递归
        if(right > l){
            quickSort(arr,l,right);
        }
    }
}

列出常用排序算法特性表：

名称	平均时间复杂度	最坏时间复杂度	最好时间复杂度	空间复杂度	稳定性
选择	n[^2]	n[^2]	n[^2]	1	不稳
冒泡	n[^2]	n[^2]	n[^2]	1	稳
+插入	n[^2]	n[^2]	n[^2]	1	稳
+堆	n*(ln n / ln 2)	n*(ln n / ln 2)	n*(ln n / ln 2)	1	不稳
希尔	n[^1.3]	n[^2]	n	1	不稳
+归并	n*(ln n / ln 2)	n*(ln n / ln 2)	n*(ln n / ln 2)	n	稳
+快排	n*(ln n / ln 2)	n[^2]	n*(ln n / ln 2)	(ln n / ln 2)	不稳
桶	n + k	n[^2]	n	n + k	稳
计数	n + k	n + k	n + k	n + k	稳
基数	n * k	n * k	n * k	n + k	稳

暂时写到这里吧，赶紧努力把排序算法学完。。。