直接插入排序、希尔排序、选择排序的基本思想和性能分析

**

一、直接插入排序

**
整个区间被分为：
1. 已排序区间：[1, bound)
2. 待排序区间：[bound, size)
每次选择无序区间的第一个元素，在有序区间内选择合适的位置插入。

代码实现

import java.util.Arrays;

public class SortDemo {
    public static void insertSort(int[] array){
        for(int bound = 1; bound < array.length; bound++){
            int tmp = array[bound];
            int cur = bound - 1;
            for(; cur >= 0; cur--){
                if(array[cur] > tmp){
                    array[cur + 1] = array[cur];
                } else {
                    break;
                }
            }
            array[cur + 1] = tmp;
        }
    }
    public static void main(String[] args) {
    	int[] arr = {9, 5, 3, 7, 2, 1, 8};
    	insertSort(arr);
    	System.out.println(Arrays.toString(arr));
    }
}

性能分析：
时间复杂度：
最好（数据有序）：O(n);
平均：O(n^2);
最坏（数据逆序）：O(n^2);
空间复杂度：O(1)

稳定性：稳定

特点：
1）如果当前这个序列很短，那么插入的效率很高。
2）如果当前这个序列基本有序，那么插入排序效率也很高。

**

二、希尔排序

**
希尔排序法又称缩小增量法。
希尔排序法的基本思想是：先选定一个整数，把待排序文件中所有记录分成n个组，所有距离为n的记录分在同一组内，并对每一组内的记录进行排序。然后，重复上述分组和排序的工作。当到达n=1时， 所有记录在同一组内排好序。
1. 希尔排序是对直接插入排序的优化。
2. 当gap > 1时都是预排序，目的是让数组更接近于有序。当gap == 1时，数组已经接近有序的了。这样整体而言，可以达到优化的效果。

代码实现

import java.util.Arrays;

public class SortDemo {
public static void shellSort(int[] array){
    int gap = array.length;
    while(gap > 1){
        insertSortGap(array, gap);
        gap = gap / 2;
    }
    insertSortGap(array, 1);
}

private static void insertSortGap(int[] array, int gap){
    for(int bound = 1; bound < array.length; bound++){
        int tmp = array[bound];
        int cur = bound - gap;
        for(; cur >= 0; cur -= gap){
            if(array[cur] > tmp){
                array[cur + gap] = array[cur];
            } else {
                break;
            }
        }
        array[cur + gap] = tmp;
    }
}
public static void main(String[] args) {
    int[] arr = {9, 5, 3, 7, 2, 1, 8};
    shellSort(arr);
    System.out.println(Arrays.toString(arr));
}
}

性能分析：
时间复杂度：
最好（数据有序）：O(n);
平均：O(n^1.3);
最坏（比较难构造）：O(n^2);
空间复杂度：O(1)

稳定性：不稳定

**

三、选择排序

**
每一次从无序区间选出最大（或最小）的一个元素，存放在无序区间的最后（或最前），直到全部待排序的数据元素排完 。

代码实现

import java.util.Arrays;

public class SortDemo {
public static void selectSort(int[] array){
    for(int bound = 0; bound < array.length; bound++){
        for(int cur = bound + 1; cur < array.length; cur++){
            if(array[cur] < array[bound]){
                swap(array, cur, bound);
            }
        }
    }
}

private static void swap(int[] array, int x, int y){
    int tmp = array[x];
    array[x] = array[y];
    array[y] = tmp;
}

public static void main(String[] args) {
        int[] arr = {9, 5, 3, 7, 2, 1, 8};
        insertSort(arr);
        System.out.println(Arrays.toString(arr));
    }
}

性能分析：（数据不敏感）
时间复杂度：O(n^2)
空间复杂度：O(1)

稳定性：不稳定