归并排序算法

8.1.1 归并排序算法(Divide-and-conquer) 方法

伪码描述：

算法： mergeSort(S,N)

输入： n个元素的组成的无需序列S

输出：经排序，S 成为有序的序列

{

      if( 1<n){

   S1=S[0..[n/2]-1];

mergeSort(s1,[n/2]);

  s=merge(s1,s2);

}

 

}

 

因此，若将归并的排序的算法处理长度为N的蓄力恶的所需的时间基座T（n），则有如下ide递归关系的成立：

 T（n）=2xT(n/2)+o(n);

 另外，当子序列长度算算为1时，递归的即可种植，并将该序列作为解直接返回。故有

T(1)

有这个两个条件可以导出：

因此，归并排序可以在的时间内对长度为n 的序列完成排序。

 

8.1.3 归并操作，就是将两个有序例子合并为一个整体的有序的蓄力，从上面的分析可以看出，

在线程时间内完成规格并，是排序算法能够达到的复杂度的关键。

有序向量的归并

首先考虑两个有序的自向量的归并，具体算法：

算法：mergeVector(s1,s2)

输入：两个非降的有序子向量的s1和s2,长度分别为n和m.

输出：  将s1 和s2归并为非讲叙列表S 

{

   0.初始化的一个空的列表S；

  1. while(!S1.isempty() or ! S2.isemptry()){

 // 在两个子类表比那位空之气那，不断的累出两个首元素的中的小者e

 if( S1.isEmpty() ){

}else if(S2.isempty)

remove(S1.first);

else if(S1.first().element()>S2.first().element)

else

  //将该元素的插入至尾部

  S.insertLast(e);

返回 S；

 

引入定理： 

算法： mergeVector可在O（n+m） 时间内完成长度的为n和m 的有序向量的归并。

 证明：

      第1局的只需要的o（1 ） 的时间。

    第2据到第 7局的是一个循环，每经过以西迭代的，S1和S2的总长度都会素缎一个单位，因为共需要跌倒i

n+m次。

每次迭代中，只需要要进行常说此的比较猜哦在，getAtRank()操作，replace AtRank() 操作和removeAtRank（) 操作，

根据3.1.2 对向量操作的复杂度分析,每一个getAtRank()和replaceAtRank()操作只需要o（1）的时间，虽然的向量元素的删除操作removeAtRank()在情况下的需要的O(n)时间，但是由于的这里删除的总是向量的最后的一个元素，无需的对后续的元素做迁移处理。故也可以在o(1)时间内完成。总傻瓜说是，每次的贴袋的都可以在常数时间的内完成，整个循环只需要的O(n+m)时间。

 

}

 

算法：mergeList(S1,S2)

输入： 两个非降序的有序列表的S1和S2，长度分别为n和m

输出： 将S 1和S2 归并为非降序的表S

{

  0。初始化一个空的列表S；

  1.while(!S1.isempty() or  ! s2.isempty()){
 //在两个子列中变为空的之前，不算抛出两个首元素的小的部分

     if(S1.isEmpty()){

    
}else if(s2.isempty() ){

remove(s1,first);

}else

{

//将该元素的插入到S的尾部

 S.insertLast(e);

返回S；

 

 

}

 

 

 

 

}

 

}

 

 

 

public class Sorter_Mergesort   implements  Sorter{

    protected  Comparator C;

    public Sorter_Mergesort(){
        this(new ComparatorDefault());
    }

    public Sorter_Mergesort(Comprator comp){
         C=comp;
    }

    public void sort(Sequence S){

        int n=S.getSize();
        if (1>n){
            return;
        }

        Sequence S1=new Sequence_DLNode();
        Sequence S2=new Sequence_DLNode();

        while(!S.isempty()){ //将S均匀的分成两个子序列S1和S2
            S1.insertLast(S.remove(S.first())){
                if (!S.isEmpty())
                    S2.insertLast(S.remove(S.first()));
            }

        }
        sort(S1);
        sort(S2);
        merge(S,S1,S2);


    }



    public void  merge(Sequence S,Seqence S1,Seqence S2){
        while (！S1.isemptu() || !S2.isEmpty()){
            Object e;
            if (S1.isEmpty()){
                e=S2.remove(S2.first());
            }else if(S2.isEmpty()) {
               e=S1.remove(S1.first);
            }else if (0<C.compare(S1.first().getElem(),S2.first().getElemt)){
                    e=S2.remove(S2.first);
            }else
                  e=S1.remove(S1.first);
        }
        S.insertLast(e);
    }

}

 

}