排序算法2——（希尔、堆、归并）

一.希尔排序

算法复杂度：O(nlogn)

希尔排序也被称为“缩小增量排序”，是一种效率更高的插入排序，步长为1时希尔排序就是插入排序。

原理：先将待排序的数组元素分成多个子序列（这些子序列是以相对步长为区分单位的，相隔步长相同的元素在同一个组中），使得每个子序列的元素个数相对较少，然后对各个子序列分别进行插入排序，待整个排序序列“基本有序后”，最后再对所有元素进行一次插入排序。

示例代码如下：

public class shell {
    public static void shellSort(int array[]){
        int i,j,h,temp;
        int length = array.length;
        for(h=length/2;h>0;h=h/2){
            for(i=h;i<length;i++){
                temp = array[i];
                for(j=i-h;j>=0;j-=h){
                    if(temp<array[j])
                        array[j+h] = array[j];
                    else
                        break;
                }
                array[j+h] = temp;
            }
        }
    }
    
    
    public static void main(String[] args){
        int a[] = {5,4,9,8,7,6,0,1,3,2};
        int len = a.length;
        shellSort(a);
        for(int i=0;i<len;i++){
            System.out.println(a[i]+" ");
        }
    }
}

二.堆排序

算法复杂度：O(nlogn)

堆是一种特殊的树形结构，每个节点都有一个值，通常提到堆都是指一个棵完全二叉树，根节点的值小于（或大于）两个子节点的值，同时，根节点的两个子树也分别是一个堆。

原理：对于给定的n个记录，初始时把这些记录看作一棵顺序存储的二叉树，然后将其调整为一个大顶堆，然后将堆的最后一个元素与堆顶元素（即二叉树的根节点）进行交换后，堆的最后一个元素即为最大记录；接着将前（n-1）个元素程序调整为一个大顶堆，再将对顶元素与当前堆的最后一个元素进行交换后得到次大的记录，重复该过程直到调整的堆中只剩一个元素时为止，该元素即为最小记录，此时便可得到一个有序序列。

堆排序主要包括两个过程：一是构建堆，二是交换堆顶元素与最后一个元素的位置。

示例程序如下：

public class heap {
    public static void HeapAdjust(int[] a,int pos,int len){
        int j,temp = a[pos];
        for(j = 2*pos + 1; j <= len; j =(2*j + 1)){//a[]中元素的下标是从0开始的。
                                                   //如果写成for(j = 2*pos; j <= len; j *= 2) 则表示a[]中元素的下标是从1开始的。
            if(j < len && a[j] < a[j+1])
                ++j;
            if(temp >= a[j])
                break;
            a[pos] = a[j];
            pos = j;
        }
        a[pos] = temp;
    }
    
    public static void HeapSort(int a[]){
        int length = a.length;
        int i;
        for(i = length/2; i >= 0; i--)
            HeapAdjust(a, i, length-1);
        for(i = length-1; i >= 0; i--){
            int tem = a[0];
            a[0] = a[i];
            a[i] = tem;
            HeapAdjust(a, 0, i-1);
        }
    }
    
    public static void main(String[] args){
        int a[] = {5,4,9,8,7,6,0,1,3,2};
        int len = a.length;
        HeapSort(a);
        for(int i = 0; i < len; i++){
            System.out.println(a[i]+" ");
        }
    }
}

三.归并排序

算法复杂度：O(nlogn)

归并排序是利用递归与分治技术将数据序列划分成越来越小的半子表，再对半子表排序，最后再用递归方法将排序好的半子表合并成越来越大的有序序列。

原理：对于给定的n个记录，首先将每两个相邻长度为1的子序列进行归并，得到n/2个长度为2或1的有序子序列，再将其两两归并，反复执行此过程直到得到一个有序序列。

示例程序如下：

public class merge {
    public static void Merge(int[] a,int p,int q,int r){
        int i,j,k,n1,n2;
        n1 = q-p+1;
        n2 = r-q;
        //创建并初始化左右数组
        int[] L = new int[n1];
        int[] R = new int[n2];
        for(i=0,k=p;i<n1;i++,k++)
            L[i] = a[k];
        for(j=0,k=q+1;j<n2;j++,k++)
            R[j] = a[k];
        //主要的排序工作
        for(k=p,i=0,j=0;i<n1&&j<n2;k++){
            if(L[i]<R[j]){
                a[k] = L[i];
                i++;
            }
            else{
                a[k] = R[j];
                j++;
            }
        }
        //排序扫尾工作
        if(i<n1){
            for(j=i;j<n1;j++,k++)
                a[k] = L[j];
        }
        if(j<n2){
            for(i=j;i<n2;i++,k++)
                a[k] =R[i];
        }
    }
    public static void MergeSort(int[] a,int p,int r){
        if(p<r){
            int q = (p+r)/2;
            MergeSort(a,p,q);
            MergeSort(a,q+1,r);
            Merge(a,p,q,r);
        }
    }
    
    public static void main(String[] args){
        int a[] = {5,4,9,8,7,6,0,1,3,2};
        int len = a.length;
        MergeSort(a,0,len-1);
        for(int i=0;i<len;i++){
            System.out.println(a[i]+" ");
        }
    }
}