1. 冒泡排序法

1.1 排序思路

按数据位置比较数据两两交换即比较位置N和N+1的大小决定是否交换位置如下图：

最后得到当前需要交换的数组长度的最大值位置，这是一轮交换后得到的数据，如有N个数据则需要进行N-1轮交换。
每一轮交换后得到数据如下图：

1.2 代码

private static void BubbleSort(int[] array){
    for(int i=0;i<array.length-1;i++){
        for(int j=0;j<array.length-i-1;j++){
             if(array[j]>array[j+1]){
                 int temp = array[j];
                 array[j]=array[j+1];
                 array[j+1]=temp;
             }
        }
    }
     System.out.println(Arrays.toString(array));
}

2.选择排序

2.1 排序思路

选择出剩余数组（n-i）数组中最小值放入对应的位置（i）

2.2 代码

private static void SelectionSort(int[] array) {
    for (int i = 0; i < array.length - 1; i++) {
        int minIndex = i;
        for (int j = i + 1; j < array.length; j++) {
            if (array[j] < array[minIndex]) {
                minIndex = j;
            }
        }
        //当数据位置不变时跳过交换
        if (i != minIndex) {
            int temp = array[i];
            array[i] = array[minIndex];
            array[minIndex] = temp;
        }
    }
    System.out.println(Arrays.toString(array));
}

3. 插入排序

3.1 排序思路

将一个记录插入到已排好序的序列中，从而得到一个新的有序序列。

3.2 代码

private static void InsertSort(int[] array) {

    for (int i = 1; i < array.length; i++) {
        int insertValue = array[i];
        int j = i - 1;
        for (; (j >= 0) && insertValue < array[j]; j--) {
            array[j + 1] = array[j];
        }
        array[j + 1] = insertValue;
    }
    System.out.println(Arrays.toString(array));
}

4. 希尔排序

4.1 排序思路

希尔排序是插入排序的改进方案，把数据按一定增量分组，对每组数据进行插入排序，随着增量逐渐减少，每组需要插入排序的循环次数减少，当增量减至1时，整个文件恰被分成一组，做最好的插入排序得到最终结果。

4.2 代码

private static void shellSort(int[] array) {
        for(int d = array.length/2;d>0;d=d/2){
            for(int i=d;i<array.length;i++){
                int insertValue = array[i];
                int j=i-d;
                for(;j>=0&&insertValue<array[j];j=j-d){
                    array[j+d]=array[j];
                }
                array[j+d]=insertValue;
            }

        }
       System.out.println(Arrays.toString(array));
    }

经典排序算法