算法时间复杂度为O(n²)的排序

1. 冒泡排序（弊端：元素交换次数太多了。）
2. 选择排序 (弊端：当数列包含多个值相等的元素时，选择排序有可能打乱它们原有的顺序)
3. 插入排序

算法思想

维护一个有序区，把元素一个个插入有序区的适当位置，直到所有元素都有序为止。

具体流程

无序数组：

首元素5作为有序区，此时有序区只有这一个元素

让元素8和有序区的元素依次比较。（8>5，所以元素8和元素5无须交换）
此时有序区的元素增加到两个

元素6和有序区的元素依次比较（6<8，所以把元素6和元素8进行交换；6>5，所以元素6和元素5无须交换）
有序区的元素增加到3个：

。。。。。
插入排序一共会进行（数组长度-1）轮，每一轮的结果如下：

JAVA实现

public static void MyInsertSort(int[] array){
        //控制循环轮数
        // i也就是有序区域的边界+1（比如i=1则，下标为0的就是有序区域）
        for (int i = 1; i < array.length; i++) { 
            int temp = array[i]; //定义待交换元素
            int j; //定义待插入的位置
            //j的范围从有序区域边界+1到0（数组下标从i到0）
            for (j = i; j > 0 && temp < array[j - 1]; j --) {
                array[j] = array[j - 1];//只做覆盖，最后一步才赋值
            }
            //赋值
            //到这一步，j就是插入位置的数组下标。
            array[j] = temp;
            System.out.println("第" + i + "轮的排序结果为：" + Arrays.toString(array));
        }
    }

测试方法：

public static void main(String[] args) {
        int[] numbers = {5,8,6,3,9,2,1,7};
        System.out.println("排序前的结果为：" + Arrays.toString(numbers));
        MyInsertSort(numbers);
        System.out.println("排序后的结果为：" + Arrays.toString(numbers));
    }

代码中优化的地方：

把每一个新元素插到有序区的时候，并不需要一步一步进行元素的两两交换，
可以先覆盖，最后赋值

暂存元素3

int temp = array[i]; //定义待交换元素

和前一个元素比较，由于3<8，复制元素8到它下一个位置；进一步循环。。。。

for (j = i; j > 0 && temp < array[j - 1]; j --) {
                array[j] = array[j - 1];//只做覆盖，最后一步才赋值
            }

最后一步，把暂存的元素3赋值到数组的首位

            //赋值
            //到这一步，j就是插入位置的数组下标。
            array[j] = temp;

时间复杂度：O(n²)
空间复杂度：O(1)