其他分享
首页 > 其他分享> > 归并排序

归并排序

作者：互联网

归并排序

2.2.1递归

正式学习归并排序之前，我们得先知道一下递归算法。

定义：

定义方法时，在方法内部调用方法本身，称之为递归。

public void show(){
	System.out.println("aaaa");
	show();
}

作用：

​ 它通常把一个大型复杂的问题，层层转换为一个与原问题相似的，规模较小的问题来求解。递归策略只需要少量的 程序就可以描述出解题过程所需要的多次重复计算，大大地减少了程序的代码量。

注意事项：

​ 在递归中，不能无限制的调用自己，必须要有边界条件，能够让递归结束，因为每一次递归调用都会在栈内存开辟新的空间，重新执行方法，如果递归的层级太深，很容易造成栈内存溢出。

需求：

请定义一个方法，使用递归完成求N的阶乘；

public class TestFactorial {
    //求n的阶乘
    public static void main(String[] args) {
        long factorial = factorial(5);
        System.out.println(factorial);
    }

    public static long factorial(int n) {
        if (n == 1){
            return 1;
        }
        return n*factorial(n-1);
    }
}
2.2.2 归并排序

​ 归并排序是建立在归并操作上的一种有效的排序算法，该算法是采用分治法的一个非常典型的应用。将已有序的子 序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序 表，称为二路归并。

需求：

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

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

排序原理：

1.尽可能的一组数据拆分成两个元素相等的子组，并对每一个子组继续拆分，直到拆分后的每个子组的元素个数是 1为止。

2.将相邻的两个子组进行合并成一个有序的大组；

3.不断的重复步骤2，直到最终只有一个组为止。

归并排序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 greater(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 : 完成归并操作需要的辅助数组

归并原理：






代码实现：



import java.util.Arrays;

public class Merge {
    //排序代码

        private static Comparable[] assist;//归并所需要的辅助数组
        /*
        对数组a中的元素进行排序
        */
        public static void sort(Comparable[] a) {
            assist = new Comparable[a.length];
            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;
            }
            int mid = lo + (hi - lo) / 2;
//对lo到mid之间的元素进行排序；
            sort(a, lo, mid);
//对mid+1到hi之间的元素进行排序；
            sort(a, mid+1, hi);
//对lo到mid这组数据和mid到hi这组数据进行归并
            merge(a, lo, mid, hi);
        }
        /*
        对数组中，从lo到mid为一组，从mid+1到hi为一组，对这两组数据进行归并
        */
        private static void merge(Comparable[] a, int lo, int mid, int hi) {
//lo到mid这组数据和mid+1到hi这组数据归并到辅助数组assist对应的索引处
            int i = lo;//定义一个指针，指向assist数组中开始填充数据的索引
            int p1 = lo;//定义一个指针，指向第一组数据的第一个元素
            int p2 = mid + 1;//定义一个指针，指向第二组数据的第一个元素
            //比较左边小组和右边小组中的元素大小，哪个小，就把哪个数据填充到assist数组中
            while (p1 <= mid && p2 <= hi) {
                if (less(a[p1], a[p2])) {
                    assist[i++] = a[p1++];
                } else {
                    assist[i++] = a[p2++];
                }
            }
//上面的循环结束后，如果退出循环的条件是p1<=mid，则证明左边小组中的数据已经归并完毕，如果退
           // 出循环的条件是p2<=hi,则证明右边小组的数据已经填充完毕；
//所以需要把未填充完毕的数据继续填充到assist中,//下面两个循环，只会执行其中的一个
            while(p1<=mid){
                assist[i++]=a[p1++];
            }
            while(p2<=hi){
                assist[i++]=a[p2++];
            }
//到现在为止，assist数组中，从lo到hi的元素是有序的，再把数据拷贝到a数组中对应的索引处
            for (int index=lo;index<=hi;index++){
                a[index]=assist[index];
            }
        }
    /*
    比较v元素是否小于w元素
    */
    private static boolean less(Comparable v, Comparable w) {
        return v.compareTo(w) < 0;
    }
    /*
    数组元素i和j交换位置
    */
    private static void exch(Comparable[] a, int i, int j) {
        Comparable t = a[i];
        a[i] = a[j];
        a[j] = t;
    }

//测试代码

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

}
}

归并排序比选择冒泡都要快

归并排序时间复杂度分析：

​ 归并排序是分治思想的最典型的例子，上面的算法中，对a[lo...hi]进行排序，先将它分为a[lo...mid]和a[mid+1...hi] 两部分，分别通过递归调用将他们单独排序，最后将有序的子数组归并为最终的排序结果。该递归的出口在于如果 一个数组不能再被分为两个子数组，那么就会执行merge进行归并，在归并的时候判断元素的大小进行排序。

用树状图来描述归并，如果一个数组有8个元素，那么它将每次除以2找最小的子数组，共拆log8次，值为3，所以 树共有3层,那么自顶向下第k层有2k个子数组，每个数组的长度为2(3-k)，归并最多需要2^(3-k)次比较。因此每层 的比较次数为 2^k * 2(3-k)=23,那么3层总共为 32^3。 假设元素的个数为n，那么使用归并排序拆分的次数为log2(n),所以共log2(n)层，那么使用log2(n)替换上面32^3中 的3这个层数，最终得出的归并排序的时间复杂度为：log2(n)* 2^(log2(n))=log2(n)*n,根据大O推导法则，忽略底 数，最终归并排序的时间复杂度为O(nlogn);

归并排序的缺点：

需要申请额外的数组空间，导致空间复杂度提升，是典型的以空间换时间的操作。

标签：归并,int,Comparable,hi,数组,排序
来源： https://www.cnblogs.com/wakanda-forever/p/16390028.html