一、冒泡排序

代码实现：

import java.util.Arrays;
public class Bubble {
    public static void main(String[] args) {
        int[] array = {2,12,4,24,3,2,34,12,33,24,28};
        int temp;
        int a = array.length;                    
        for (int i = 0; i < a; i++) {
            int b = array.length-1-i;
            for (int j = 0; j < b; j++) {                //每次比较都筛选出一个最大的元素，每次遍历减一，可以减少开销
                if (array[j+1] < array[j]){
                    temp = array[j];
                    array[j] = array[j+1];
                    array[j+1] = temp;
                }
            }
        }
        System.out.println(Arrays.toString(array));
    }
}

代码实现阐述：

• 比较相邻的元素。如果第一个比第二个大，就交换它们两个；
• 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对，这样在最后的元素应该会是最大的数；
• 针对所有的元素重复以上的步骤，除了最后一个；
• 重复步骤1~3，直到排序完成。

二、选择排序

• 时间复杂度为O(n²)

• 空间复杂度为O(1)
• 不稳定的排序算法

代码实现：

import java.util.Arrays;
public class Selection {
    public static void main(String[] args) {
        int[] array = {2, 12, 4, 24, 3, 2, 34, 12, 33, 28, 23};
        int temp;
        if (array == null || array.length == 0) {
            return;
        }
        for (int i = 0; i < array.length; i++) {
            //记录最小元素下标
            int minIndex = i;
            for (int j = i+1; j < array.length; j++) {
                if (array[j] < array[minIndex]) {
                    //更新下标
                    minIndex = j;
                }
            }
            if (minIndex != i) {
                System.out.println("++++++++");
                temp = array[minIndex];
                array[minIndex] = array[i];
                array[i] = temp;
            }
        }
        System.out.println(Arrays.toString(array));
    }
}

三、插入排序

通过构建有序数列，对于未排序元素，在已排序数列中从后往前扫描，找到相应位置并插入。

1.将一个具有n个元素的待排序数列分成两个子数列，一个有序和一个无序。
2.刚开始，我们将左边第一个元素看成一个有序数列，右边n-1个元素看成无序数列。
3.从右边无序数列中取出一个元素，在已排序数列中从后往前扫描（比较），找到相应的位置并插入，使插入后有序数列仍然有序。
4.重复第3步，直到完成整个排序过程。

import java.util.Arrays;
public class Innsertion {
    public static void main(String[] args) {
        int[] array = {2, 12, 4, 24, 3, 2, 34, 12, 33, 28, 23};
        if (array == null || array.length == 0) {
            return;
        }
        for (int i = 1; i < array.length; i++) {
            int temp = array[i];
            int index = i - 1;
            while (index >= 0 && array[index] > temp) {
                array[index + 1] = array[index];
                index--;
            }
            array[index + 1] = temp;
        }
        System.out.println(Arrays.toString(array));
    }
}

三、希尔排序

又称缩小增量排序，是一种改进的排序算法，通常选择希尔增量gap=length/2，虽然这个增量不是最优的，但是很通用，普且自信(🐴)。

import java.util.Arrays;
public class Shell {
    public static void main(String[] args) {
        int[] array = {2, 12, 4, 24, 3, 2, 34, 12, 33, 28, 23};
        int len = array.length;
        int gap = len / 2;
        while (gap > 0) {
            for (int i = gap; i < len; i++) {
                int temp = array[i];
                int index = i - gap;
                while (index >= 0 && array[index] > temp) {
                    array[index + gap] = array[index];
                    index -= gap;
                }
                array[index + gap] = temp;
            }
            gap /= 2;
        }
        System.out.println(Arrays.toString(array));
    }
}