关闭

排序算法总结(7)--归并排序

标签: 排序算法Java
66人阅读 评论(0) 收藏 举报
分类:

一、简介

理解归并排序有两种思路:1、自顶向下化整为零,2、自底向上循序渐进
1、自顶向下:将无序序列平均分成两部分,分别对这两部分排序,然后合并。这样将一个大问题分解成两个小问题。同理,如何对两个小部分进行排序?分别将它们分解为更小的问题。在这个算法中,分解问题很简单,主要是如何合并两个小序列为一个有序序列。
2、自底向上:首先将长度为n的序列分解成n个长度为1的序列,成对的合并它们,成为n/2个长度为2的有序序列。然后再成对合并,直到合并成原来的长度。这里的关键在于合并序列。
所以归并排序的关键在于合并。如何合并两个有序序列呢?给定两个序列A[p,…q]和A[q+1,…r],都是已经排序好的。首先将两个子序列复制,有两个指针i,j,分别指向复制后的两个序列的起始位置。从两个指针指向的元素中选择较小的元素,放入A[p,…,r]中,对应子序列上的指针向后移。直到其中一个序列遍历完毕,将另一个序列剩余的元素全部放入A[p,…,r]。

二、代码实现

2.1 合并

伪代码

megre(array,p,q,r)
        n1=q-p+1;
        n2=r-q;
        letL[0,...,n1] and R[0,...,n2]是两个新的数组
        将 array[p,...,q]复制到L,array[q+1,...,r]复制到R
        且arrarR和arrayL中最后一个数是Integer.MAX_VALUE
        //合并开始
        i=0;
        j=0;
        for k=p to r
            if L[i]<=R[j]
                array[k]=L[i];
                i++;
            else
                array[k]=R[j];
                j++;

在复制两个子序列时,在他们最后分别放上一个无穷大的值作为哨兵,用于简化代码。当指针指向其中一个哨兵时,他不可能是较小的值,除非两个指针都指向哨兵,此时所有元素已经合并完毕。

代码实现

public static void megre(int[] array,int p,int q,int r){
        int n1=q-p+1;
        int n2=r-q;
        int[] arrayL=new int[n1+1];
        int[] arrayR=new int[n2+1];
        for(int i=0;i<n1;i++){
            arrayL[i]=array[p+i];
        }


        arrayL[n1]= Integer.MAX_VALUE;

        for(int i=0;i<n2;i++){
            arrayR[i]=array[q+1+i];
        }
        arrayR[n2]= Integer.MAX_VALUE;

        int i=0;
        int j=0;
        for(int k=p;k<=r;k++){
            if (arrayL[i]<=arrayR[j]){
                array[k]=arrayL[i];
                i++;

            }else{
                array[k]=arrayR[j];
                j++;
                }
            }
        }

2.2 自顶向下的归并排序

public static void topMegreSort(int[] array,int p,int r){
        if (p<r){
            int q=(p+r)/2;
            megreSort(array,p,q);
            topMegreSort(array,q+1,r);
            topMegreSort(array,p,q,r);
        }
    }

2.3 自底向上的归并排序

public static void bottomMegreSort(int [] array){
        int n=array.length;
        for(int sz=1;sz<n;sz*=2){
            for(int i=0;i<n-sz;i+=sz+sz){
                megre(array,i,i+sz-1,Math.min(i+sz+sz-1,n-1));
            }
        }
    }

三、递归方程

自顶向下的归并排序应用了递归的思想,如何从递归的算法中分析时间复杂度呢?我们可以使用递归方程或递归式来描述其运行时间,该方程根据在较小输入上的运行时间来描述在规模为n的问题上的总运行时间。然后通过数学工具求解该递归式给出算法的时间复杂度。例如,在归并排序中,假设T(n)是问题规模为n时的运行时间,将原问题分解为2个规模为n/2的子问题,每个问题的运行时间为T(n/2)分解和合并所需的时间是O(n),所以
这里写图片描述
如何求解用递归方程表示的时间复杂度?参见http://www.cnblogs.com/python27/archive/2011/12/09/2282486.html
主要介绍了代入法,迭代法,公式法,母函数法,差分方程法。

四、注意事项

1、归并排序的空间复杂度并不是O(1),在合并的过程中,需要辅助空间
2、归并排序直到递归结束才能确定所有元素的最终位置。

0
0

猜你在找
查看评论
* 以上用户言论只代表其个人观点,不代表CSDN网站的观点或立场
    个人资料
    • 访问:2351次
    • 积分:165
    • 等级:
    • 排名:千里之外
    • 原创:15篇
    • 转载:6篇
    • 译文:0篇
    • 评论:0条
    文章分类
    文章存档