初级排序算法

前言

回顾之前学习的各种排序算法，从初级到高级，包括选择排序，冒泡排序，插入排序，希尔排序，快速排序，归并排序，堆排序等等，持续更新中…

注：这里实现的算法都是递增排序，也就是从小到大排序。

初级排序算法

1.选择排序

思想：首先，找到数组中最小的那个元素，其次，将它和数组的第一个元素交换位置（如果第一个元素就是最小元素那么它就和自己交换）。再次，在剩下的元素中找到最小的元素，将它与数组的第二个元素交换位置。如此往复，直到将整个数组排序。

public static int [] sort(int a[],int length){    //选择排序
    for(int i=0;i<length;i++){
        int minIndex = i; //初始化最小元素的索引
        for(int j=i+1;j<length;j++){
            if(a[minIndex]>a[j]){
                minIndex = j;  //找到最小元素的索引
            }
        }
        int tem = a[i];
        a[i] = a[minIndex];
        a[minIndex] = tem;
    }
    return a;
}

2.直接插入排序

思想： 每一步将一个待排序的记录，插入到前面应排好序的有序序列中去，直到查完所有元素为止。

代码：

第一种：从后往前依次比较前面排好序的有序序列，如果插入元素较小时，交换，j- -,继续比较。

public static int [] sort(int a[],int length){
    for(int i=1;i<a.length;i++){
        for(int j=i;j>0&&a[j]<a[j-1];j--){  
            int tem = a[j-1];
            a[j-1] = a[j];
            a[j] = tem;
        }
    }
    return a;
}

第二种：不需要交换的直接插入排序，将内循环中较大的元素都向右移动而不总是交换两个元素，从而提高效率。

public static int [] sort(int a[],int length){    //不需要交换的插入排序
    for(int i=1;i<a.length;i++){
        int tem = a[i];  //待插入的元素
        int j;
        for(j=i-1;j>=0&&tem<a[j];j--){
            a[j+1] = a[j];   //元素后移,直到找到待插入的元素的位置
        }
        a[j+1] = tem;  //将带插入元素插入到查找到的位置
    }
    return a;
}

第三种：此外还可以通过增加哨兵的形式，在插入排序的实现中先找出最小的元素并将其置于数组的最左边，这样就能去掉内循环的判断条件j>0。这是一种常见的规避边界测试的方法，能够省略判断条件的元素通常被称为哨兵。

public static int [] sort(int a[],int length){
    int minIndex =0;
    for(int i=1;i<length;i++){
        if(a[minIndex]>a[i]){
            minIndex = i;
        }
    }
    int tem = a[0];
    a[0] = a[minIndex];
    a[minIndex] = tem;
    for(int i=2;i<length;i++){
        tem = a[i];
        int j;
        for(j=i-1;tem<a[j];j--){
            a[j+1] = a[j];
        }
        a[j+1] = tem;
    }
    return a;
}

3.希尔排序

思想：希尔排序是把记录按下标的一定增量分组，对每组使用直接插入排序算法排序；随着增量逐渐减少，每组包含的关键词越来越多，当增量减至1时，整个文件恰被分成一组，算法便终止。

简单插入排序很循规蹈矩，不管数组分布是怎么样的，依然一步一步的对元素进行比较，移动，插入，比如[5,4,3,2,1,0]这种倒序序列，数组末端的0要回到首位置很是费劲，比较和移动元素均需n-1次。而希尔排序在数组中采用跳跃式分组的策略，通过某个增量将数组元素划分为若干组，然后分组进行插入排序，随后逐步缩小增量，继续按组进行插入排序操作，直至增量为1。希尔排序通过这种策略使得整个数组在初始阶段达到从宏观上看基本有序，小的基本在前，大的基本在后。然后缩小增量，到增量为1时，其实多数情况下只需微调即可，不会涉及过多的数据移动。

我们来看下希尔排序的基本步骤，在此我们选择增量gap=length/2，缩小增量继续以gap = gap/2的方式，这种增量选择我们可以用一个序列来表示，{n/2,(n/2)/2…1}，称为增量序列。希尔排序的增量序列的选择与证明是个数学难题，我们选择的这个增量序列是比较常用的，也是希尔建议的增量，称为希尔增量，但其实这个增量序列不是最优的。此处我们做示例使用希尔增量。

代码：

public static int[] sort(int a[],int length){
    int h = length/2; //初始增量
    while(h>=1){
        //将数组变为h有序
        for(int i=h;i<length;i++) {
            //将a[i]插入到a[i-h],a[i-2*h],a[i-3*h]...之中
            for(int j=i;j>=h&&a[j]<a[j-h];j-=h){
                int tem = a[j-h];
                a[j-h] = a[j];
                a[j] = tem;
            }
        }
        h = h/2; //每次排完序后,增量减少
    }   
    return a;
}

参考：dreamcatcher-cx