排序算法总结（二）——插入排序

1.直接插入排序
基本思想：将无序序列隐式的分成两部分，一部分是有序的，一部分是无序的，通过比较大依次将无序部分中的元素插入在有序部分中的正确位置上。
初始时，有序部分有且仅有一个元素，每次插入后，有序部分元素增加一个，无序部分减少一个。插入排序的关键是如何正确找到插入点。

算法步骤：
A. 初始时，选择a[0]作为有序部分；
B. 将a[1]与a[0]比较，如果a[1] < a[0]，将两者交换；此时a[0]a[1]即为有序部分；
C.从后向前遍历有序部分，将a[2]与a[1]进行比较，如果a[2] < a[1]，则进行交换；以此将a[1]与a[0]进行比较，同样a[1] < a[0]则进行交换，由此将原始序列中的a[3]插入到合适位置上。
D. 以此类推，将a[i]插入到有序部分合适的位置。

代码实现如下：

public class InsertedSort {

    public static void main(String[] args) {
        int[] a = {2,3,1,4,6,0};
        sort(a);
        for(int i = 0;i<a.length;i++)
            System.out.println(a[i]);

    }

    public static void sort(int[] a){
        int len = a.length;
        for(int i=1;i<len;i++){
            for(int j=i-1;j>-1;j--){
                if(a[j+1]<a[j]){
                    int temp = a[j];
                    a[j] = a[j+1];
                    a[j+1] = temp;
                }
            }
        }
    }
}

---

2.折半插入排序
折半查找是对直接插入查找的改进，直接插入查找是不断从尾到头遍历、比较、移动将待插入的元素插入到正确的位置，但是因为被插入的序列是有序的，所以可以直接通过折半查找在有序序列中找到插入点。
基本思想：通过折半查找找到元素插入点，然后移动数据，插入元素。

代码实现：

public class HalfInsertSort{

    public static void main(String[] args) {
        int[] a = {5,3,1,4,6,7,0};
        sort(a);
        for(int i = 0;i<a.length;i++)
            System.out.println(a[i]);
    }

    public static void sort(int[] a){
        int len = a.length;
        for(int i = 1;i<len;i++){
            if(a[i]<a[i-1]){
                int temp = a[i];
                int h = 0; //有序序列头部
                int t = i-1; //有序序列尾部

                //折半查找插入点
                while(h<=t){
                    int mid = (h+t)/2; 
                    if(temp > a[mid])
                        h = mid + 1;
                    else
                        t = mid - 1;
                }

                //while循环结束后，h即为插入点，将h到i的元素依次向后移动
                for(int j=i-1;j>=h;j--){
                    a[j+1] = a[j];
                }   
                //插入到a[h]
                a[h] = temp;    
            }
        }


    }
}

---

3.希尔排序
同样是这位大神介绍的希尔排序，贼清晰，所以借鉴下，侵权删https://www.cnblogs.com/chengxiao/p/6104371.html

希尔排序是对前面两种插入排序的改进，上面两种插入方法都将待插入值存到临时变量，需要通过不断比较找到插入点，然后多次交换（移动）元素，从而得到有序的目的。
那么如果有一个最小的元素却位于序列的最右端，在排序过程中，所有元素都要向右移动，显然效率是相对来说比较慢的。
希尔排序通过增大插入排序之间的间隔，是个数据之间有跨度的移动，而不是一格格的移动，并且在每轮排序后，缩小上次间隔，继续排序。进行这些排序时的数据项之间的间隔称为增量。

希尔排序的基本步骤：
初始时，选择增量step=length/2，并且以step=step/2的幅度缩小增量，直到增量为1。
根据数据之间的增量，便将无序序列分为step个组，每个组分别进行直接插入排序。

如下图所示：

代码实现：
在希尔排序中，根据增量进行分组，每组依次进行直接插入排序，这样的话，需要4层循环才能完成（一层为step调成，一层为处理分组，两层进行直接插入）。
所以实现上可以循环按照分组来，从第step开始，跨组处理，每组之间并不会互相影响。

public static void sort(int[] a){
        int len = a.length;
        int step = len/2;

        //第一层for循环调整step；第二层从第step个元素开始，跨组进行直接插入排序
        for(step = len/2; step>0;step/=2){
            for(int i=step;i<len;i++){
                for(int j = i-step; j>-1; j -= step){
                    if(a[j]>a[j+step]){
                        int temp = a[j];
                        a[j] = a[j+step];
                        a[j+step] = temp;
                    }
                    //若出现待插入元素大于当前元素，那么即完成插入，无需进行下面步骤
                    else
                        continue;
                }
            }
        }

    }
}