数据结构与算法——希尔排序、归并排序、快速排序

希尔排序

希尔排序是一种插入排序，又称“缩小增量排序”，是插入排序算法的一种更高效的改进版本。

排序原理：
1.选定一个增长量h，按照增长量h作为数据分组的依据，对数据进行分组；
2.对分好组的每一组数据完成插入排序；
3.减小增长量，最小减为1，重复第二步操作。

需求：
排序前：{9,1,2,5,7,4,8,6,3,5}
排序后：{1,2,3,4,5,5,6,7,8,9}

增长量h的确认：增长量h的值每一固定的规则，我们这里采用一下规则：

int h = 1;
while(h < 数组的长度/2){
	h = 2h + 1;
}
//循环结束后可以确定h的最大值
h的减小规则为：
    h = h/2；

希尔排序的API设计：

类名	Shell
构造方法	Shell():创建Shell对象
成员方法	1.public static void sort(Comparable[] a):对数组内的元素进行排序 2.private static boolean greater(Comparable v,Comparable w):判断v是否大于w 3.private static void exch(Comparable[] a,int i,int j):交换a数组中，索引i和j处的值

public class Shell {
    public static  void sort(Comparable[] a){                     
        //根据数组a的长度，确定增长量h的初始值
        int h = 1;
        while(h < a.length/2){
            h = 2*h+1;
        }
        //希尔排序
        while(h >= 1){
            //找到待插入的排序
            for (int i = h; i < a.length ; i++) {
                //把待插入排序的元素插入到有序数列中
                for (int j = i; j >= h ; j-=h) {
                    //比较a[j],a[j-h]
                    if(greater(a[j-h],a[j])){
                        exch(a,j-h,j);
                    }else{
                        break;
                    }
                }
            }
            //减小h的值
            h = h/2;
        }
    }
    private static boolean greater(Comparable v,Comparable w){    //判断v是否大于w
        return v.compareTo(w)>0;
    }
    private static void exch(Comparable[] a,int i,int j){        //交换数组a索引i处和索引j处的值
        Comparable temp;
        temp = a[i];
        a[i] = a[j];
        a[j] = temp;
    }
}
//测试代码
import java.util.Arrays;

public class Main {
    public static void main(String[] args) {
        Integer[] a = {9,1,2,5,7,4,8,6,3,5};
        Shell.sort(a);
        System.out.println(Arrays.toString(a));
    }

}

归并排序

排序原理：
1.尽可能的一组数据拆分成两个元素想等的子组，并对每一个子组继续拆分，直到拆分后的每一个子组的元素个数是1为止。
2.将相邻的两个子组进行合并成一个有序的大组。
3.不断的重复步骤2，直到最终只有一个组为止。

需求：
排序前：{8,4,5,7,1,3,6,2}
排序后：{1,2,3,4,5,6,7,8}

归并排序API设计：

类名	Merge
构造方法	Merge():创建Merge对象
成员方法	1.public static void sort(Comparable[] a):对数组内的元素进行排序 2.private static void sort(Comparable[] a,int lo,int hi):对数组a中从索引lo到所有hi之间的元素进行排序 3.private static void merge(Comparable[] a,int lo,int mid,int hi):从索引lo到索引mid一个子组，从索引mid+1到索引hi为另一个子组，把数组a中的这两个子组的数据合并成一个有序的大组(从索引lo到索引hi) 4.private static boolean less(Comparable v,Comparable w):判断v是否小于w 5.private static void exch(Comparable[] a,int i,int j):交换a数组中索引i和索引j处的值
成员变量	1.private static Comparable[] assist:完成归并并需要的辅助数组

代码实现：

public class Merge {
    //归并所需要的辅助数组
    private static Comparable[] assist;
    private static boolean less(Comparable v,Comparable w){
        return v.compareTo(w) < 0;
    }
    private static void exch(Comparable[] a,int i,int j){
        Comparable t = a[i];
        a[i] = a[j];
        a[j] = t;
    }
    public static void sort(Comparable[] a){
        //初始化辅助数组assist
        assist = new Comparable[a.length];
        //定义一个lo变量和hi变量，分别记录数组中最小的索引和最大的索引
        int lo = 0;
        int hi = a.length-1;
        //调用sort重载方法完成数组a中，从索引lo到索引hi的元素的排序
        sort(a,lo,hi);
    }
    private static void sort(Comparable[] a,int lo,int hi){
        //安全性验证
        if(hi <= lo){
            return;
        }
        //对lo到hi之间的数据进行分组
        int mid = lo+(hi-lo)/2;
        //分别对每一组数据进行排序
        sort(a,lo,mid);
        sort(a,mid+1,hi);
        //再把两组中的数据进行归并
        merge(a,lo,mid,hi);
    }
    private static void merge(Comparable[] a,int lo,int mid,int hi){
        //定义三个指针
        int i = lo;
        int p1 = lo;
        int p2 = mid+1;

        //遍历，移动指针p1和p2，比较对应索引处的值，找出小的一个，放到辅助数组的对应索引处
        while(p1 <= mid && p2 <= hi){
            //比较对应索引处的值
            if(less(a[p1],a[p2])){
                assist[i++] = a[p1++];
            }else{
                assist[i++] = a[p2++];
            }
        }

        //遍历，如果p1的指针没有走完，那么按顺序移动p1指针，把对应的元素放到辅助数组的对应索引处
        while (p1<=mid){
            assist[i++] = a[p1++];
        }

        //遍历，如果p2的指针没有走完，那么按顺序移动p2指针，把对应的元素放到辅助数组的对应索引处
        while (p2<=hi){
            assist[i++] = a[p2++];
        }

        //把辅助数组中的元素拷贝到原数组中
        for (int j = lo; j <= hi; j++) {
            a[j] = assist[j];
        }
    }
}

//测试代码
import algorithm.exclass.Merge;

import java.util.Arrays;

public class MergeTest {
    public static void main(String[] args) {
        Integer[] a = {8,4,5,7,1,3,6,2};
        Merge.sort(a);
        System.out.println(Arrays.toString(a));
    }
}

归并排序的时间复杂度：O(nlogn)

快速排序

排序原理：
1.首先设定一个分界值，通过该分界值将数组分成左右两个部分；
2.将大于或等于分界值的数据放到数组右边，小于分界值的数据放到数组的左边。此时左边部分中各元素都小于或等于分界值，而右边部分各元素都大于或等于分界值；
3.然后，左边和右边的数据可以独立排序。对于左侧的数组数据，又可以取一个分界值，将该部分数据分成左右两个部分，同样在左边放置较小值，右边放置较大值。
4.重复上述过程，可以看出这是一个递归定义。通过递归将左侧部分排好序，在递归排好右侧部分的顺序。当左侧和右侧两个部分排序完成后，整个数组的排序也完成了。

快速排序API设计：

类名	Quick
构造方法	Quick():创建Quick对象
成员方法	1.public static void sort(Comparable[] a):对数组内的元素进行排序 2.private static void sort(Comparable[] a,int lo,int hi):对数组a中从索引lo到所有hi之间的元素进行排序 3.private static int partition(Comparable[] a,int lo,int hi):对数组a中从索引lo到hi之间的元素进行分组，并返回分组界限对应的索引 4.private static boolean less(Comparable v,Comparable w):判断v是否小于w 5.private static void exch(Comparable[] a,int i,int j):交换a数组中索引i和索引j处的值

代码实现：

public class Quick {

    private static boolean less(Comparable v,Comparable w){
        return v.compareTo(w) < 0;
    }

    private static void exch(Comparable[] a,int i,int j){
        Comparable t = a[i];
        a[i] = a[j];
        a[j] = t;
    }
    //对数组内的元素进行排序
    public static void sort(Comparable[] a){
        int lo = 0;
        int hi = a.length-1;
        sort(a,lo,hi);

    }
    //对数组a中从索引lo到hi之间的元素进行排序
    private static void sort(Comparable[] a,int lo,int hi){
        //安全性验证
        if(hi <= lo){
            return;
        }

        //需要对数组中索引lo处到hi处的元素进行分组(左子组和右子组）
        int partition = partition(a,lo,hi);//返回值是分组的分界值所在的索引，分界值位置变换后的索引

        //让左子组有序
        sort(a,lo,partition-1);
        //让右子组有序
        sort(a,partition+1,hi);
    }
    //对数组a中，从索引lo到hi之间的元素进行分组。并返回分组界限对应的索引
    private static int partition(Comparable[] a,int lo,int hi){
        //确定分界值
        Comparable key = a[lo];
        //定义两个指针，分别指向待切分元素的最小索引处和最大索引处的下一个位置
        int left = lo;
        int right = hi+1;

        //切分
        while(true){
            //先从右往左扫描，移动指针right指针，找到一个比分界值小的元素
            while(less(key,a[--right])){
                if(right == lo)
                    break;
            }
            //先从左往右扫描，移动指针left指针，找到一个比分界值小的元素
            while(less(a[++left],key)){
                if(left == hi)
                    break;
            }
            //判断left>=right，如果是元素扫描完毕结束循环，如果不是，则交换元素即可
            if(left >= right){
                break;
            }else{
                exch(a,left,right);
            }
        }
        //交换分界值
        exch(a,lo,right);
        return right;
    }
}

//测试代码
import java.util.Arrays;

public class Quicktest {
    public static void main(String[] args) {
        Integer[] a = {6,1,2,7,9,3,4,5,8};
        Quick.sort(a);
        System.out.println(Arrays.toString(a));
    }
}