归并排序算法

public void hb(int r[], int strat, int mid, int end, int t[]){ 
     int i = start;
     int j  = mid +1;
     int k = 0;
     while((i<=mid) && (j<=end) ){     
         if(r[i]<r[j]){
             t[k++] = r[i++];
         }
         else
             t[k++] = r[j++];
     }
     if(i>mid)
         while(j<=end)
             t[k++] = r[j++];
     else
         while(i<mid)
             t[k++] = r[i++];
}

 

//一趟归并排序
//把数组r中的长度为s的相邻有序子表两两合并，归并成一个长度为2s的有序表，存于t数组中。
public void ytgb(int s, int n, int r[], int t[]){
    int i=0;
    while((i+2*s-1)<n)
        hb(r, i, i+s-1, i+2*s-1, t);
        i = 2*s+i;
    if((i+s)<n)
        hb(r, i, i+s-1, n-1, t);
    else
        while(i<n)
            t[i++] = r[i++];
}

 

//两路归并排序算法

public void 11gbpx(int n,int r[]){
    int s = 1;
    int t[] = new int[n]; 
    
    while(n<s){
        ytgb(s, n, r, t);
        for(int i=0;i<n;i++){
            r[i]=t[i];
        }
        s = 2*s;
    }
}

 

归并排序时间复杂度
归并排序的时间复杂度是O(N*lgN)。
假设被排序的数列中有N个数。遍历一趟的时间复杂度是O(N)，需要遍历多少次呢？
归并排序的形式就是一棵二叉树，它需要遍历的次数就是二叉树的深度，而根据完全二叉树的可以得出它的时间复杂度是O(N*lgN)。

归并排序稳定性
归并排序是稳定的算法，它满足稳定算法的定义。
算法稳定性 -- 假设在数列中存在a[i]=a[j]，若在排序之前，a[i]在a[j]前面；并且排序之后，a[i]仍然在a[j]前面。则这个排序算法是稳定的！