数据结构之插入排序

插入排序也属于内部排序，是以插入的方式寻找元素的适当位置。

基本思想：将n个待排序的元素看作一个有序列表和一个无序列表，开始时有序列表中有1个元素，无序列表中有n-1个元素，每次插入时从无序列表中取出第一个元素，将这个元素与有序列表中的元素比较大小，找到其合适的插入位置，即可得到一个有序列表。思路图如下所示：

代码如下所示：

/**
 * 插入排序：将列表看成是一个有序列表和一个无序列表，每次把无序列表中的第一个元素插入到有序
 * 列表的合适位置。
 */
public class InsertSort {
    public static void main(String[] args) {
        int[] arr = {101,34,119,1,-1,89};
        InsertSort insertSort = new InsertSort();
        insertSort.sort(arr);
        insertSort.print(arr);
    }
    private void sort(int[] arr){
        for (int i = 1; i < arr.length; i++) {
            int insertVal = arr[i];//要插入的元素值
            int index = i-1;//要插入元素的前一个位置
            while (index>=0 && arr[index] > insertVal){
                //从小到大排，把大于要插入值的元素后移
                arr[index+1] = arr[index];
                //和前面的元素比较
                index--;
            }
            if (index+1 != i){
                //找到合适的位置，插入值,index+1就是要插入的位置
                arr[index+1] = insertVal;
            }
        }
    }
    private void print(int[] arr){
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i]+" ");
        }
    }
}

这种直接插入法也有自己的缺点，当无序列表是2，3，4，5，1时，用直接插入法插入就会产生多次移位，对效率有所影响。

下面我们聊聊另一种排序方式，希尔排序把！

希尔排序是对简单插入排序的的一种改进，也称为缩小增量排序。根据增量gap将无序列表分成gap组，在在组内进行排序。组内排序有两种方法：交换法和移位法。代码中的sort1是组内交换法，sort2是移位法。

基本思路：无序数组是arr={8,9,1,7,2,3,5,4,6,0}

1. 初始增量gap=length/2=5，即将数组arr分为5组，每组中有两个元素，对这5组分别排序，5组全部排序后的结果是arr={3，5，1，6，0，8，9，4，7，2}；
2. 更新gap值，此时gap=5/2=2，将数组arr={3，5，1，6，0，8，9，4，7，2}分为2组，每组中有5个元素，对这两组的元素分别排序，此时arr={0，2，1，4，3，5，7，6，9，8}；
3. 再次更新gap，此时gap=2/2 = 1，对这一组进行排序，arr={0，1，2，3，4，5，6，7，8，9}，得到有序数组。

public class ShellSort {
    public static void main(String[] args) {
        int[] arr = {8,9,1,7,2,3,5,4,6,0};
        ShellSort shellSort = new ShellSort();
//        shellSort.sort1(arr);
        shellSort.sort2(arr);
//        shellSort.print(arr);
    }

    /**
     * 希尔排序之交换法
     * @param arr
     */
    private void sort1(int[] arr){
        int temp = 0;
        for (int gap=arr.length/2;gap>0;gap/=2){
            //此循环表示每次的增量是多少
            for (int i = gap; i < arr.length; i++) {
                //此循环表示分组后组内后面的元素
                for (int j = i-gap; j >=0 ; j-=gap) {
                    //此循环表示分组后组内前面的元素，若组内前面的元素大于后面的元素，交换
                    if (arr[j] > arr[j+gap]){
                        temp = arr[j];
                        arr[j] = arr[j+gap];
                        arr[j+gap] = temp;
                    }
                    //出此循环代表一组内的元素比完
                }
                //出此循环代表代表安增量分的所有组比完
            }
            //每个增量分组排序
            print(arr);
            System.out.println();
            //出此循环代表代表增量为0，是一个顺序数组了
        }
    }
    //希尔排序之移位法
    private void sort2(int[] arr){
        for (int gap=arr.length/2;gap>0;gap/=2){
            //划分步长
            for (int i = gap; i < arr.length; i++) {
                int temp = arr[i];
                int j = i;
                //按照步长进行组内元素比较
                while (j-gap>=0 && temp<arr[j-gap]){
                    //后移
                    arr[j] = arr[j-gap];
                    j -= gap;
                }
                //此时j就是要插入的位置
                arr[j] = temp;
            }
            print(arr);
            System.out.println();
        }
    }
    private void print(int[] arr){
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i]+" ");
        }
    }
}