常用的排序方式及java实现 - 插入排序、希尔排序、选择排序、堆排序

本篇所有算法都是从小到大排序 ！

插入排序

算法思路：

[0,bound)为已排序区间，[index，size)为待排区间（其实bound就是index，此处为了方便区分）

1. 从第二位array[1]开始遍历，当前数array[index]与已排序区间的数依次比较，如果当前数array[index]小于已排序的数，则交换二者位置。

2. 重复以上步骤，直到当前数不大于前面的任一个数为止。将当前数，放到这个位置。这一步就是保证已排序区间都是有序的，内层while循环的目的就是将当前数插入到前面的有序序列里。

3. 重复以上步骤，直到遍历到最后一位数，并将最后一位数插入到合适的位置，插入排序结束。

如图所示：

代码:

    public static void InsertSort(int []array){
        //[0,bound)为已排序区间，[index，size]为待排区间
        //取array[index]与前bound个已排序的数分别进行比较，如果大于则不变，小于则交换二者位置，
        // 直到找到合适位置插入。然后bound++，index++
        for (int bound = 1;bound < array.length;bound++){
            int index = bound;
            while (index > 0){
                if(array[index] > array[index-1])break;
                else {
                    int tem = array[index];
                    array[index] = array[index-1];
                    array[index - 1] = tem;
                    index--;
                }
            }
        }
    }

---

希尔排序

算法思路：

• 首先它把较大的数据集合分割成若干个小组（逻辑上分组），然后对每一个小组分别进行插入排序，此时，插入排序所作用的数据量比较小（每一个小组），插入的效率比较高
• 与插入排序排序稍微有区别的就在于，每次他是和另一组的相同位置进行比较。也就是array[i] > array[i - gap]
• 其他思路基本一致。

    public static void ShellSort(int []array){
        int gap = array.length;
        while (gap > 1){
            gap = gap/2;
            for (int i = gap;i<array.length;i++) {
                while (i > gap ) {
                    if (array[i] > array[i - gap])break;
                    int tem = array[i];
                    array[i] = array[i - gap];
                    array[i - gap] = tem;
                    i = i - gap;
                }
            }
        }
    }

---

选择排序

[0,bound)为已排序区间，[index，size)为待排区间

算法思路：

• 以bound位置元素为擂主，循环从待排序列表取元素进行对比。
  如array[bound] > array[index]，则交换位置，并且bound后移继续循环比较，到列表结束为止。

代码:

    public static void SelectSort(int []array){
        for(int bound = 0;bound < array.length;bound++){
            for (int index = bound +1;index < array.length;index++){
                if(array[bound]>array[index]){
                    int tem = array[index];
                    array[index] = array[bound];
                    array[bound] = tem;
                }
            }
        }
    }

---

堆排序

算法思路：

先将数组化为标准大堆，然后将第一个元素，即最大数,和最后一个数交换.然后将最后一个数划分到已排区间。
[0,array.length-1)为初始待排区间，[array.length-1,array.length)为已排区间。每删除一次最后一个数，待排区间-1，已排区间+1。即
[0,array.length-1-i)待排区间，[array.length-1-i,array.length)为已排区间。
对第一个元素进行向下调整，重新化为大堆。重复以上操作即可。

代码：

    public static void HeapSort(int []array){
        Creadheap(array);
        for(int i = 0;i<array.length-1;i++){
            swap(array,0,array.length-1-i);
            Shiftdown(array,array.length-i-1,0);
        }
    }
    public static void swap(int []array,int a,int b){
        int tem = array[a];
        array[a] = array[b];
        array[b] = tem;
    }
    
    public static void Creadheap(int []array){
    
        for(int i = (array.length - 1 - 1)/2;i >= 0;i--){
        //从最后一个非叶子节点出发，向下调整。建成大堆。
            Shiftdown(array,array.length,i);
        }
    }
    
    public static void Shiftdown(int []array,int heaplength,int index){
        int parent = index;
        int child = 2*parent +1;
        while (child < heaplength){
            if(child+1 < heaplength && array[child] < array[child+1]) child = child+1;
            if(array[child] > array[parent])swap(array,parent,child);
            else break;
            parent = child;
            child = 2*parent +1;
        }
    }