算法学习（归并排序）

算法思想：
假设初始序列含有n个记录，则可以看成是n个有序的子序列，每一个子序列的长度都是1，然后把这些子序列两两归并，得到⌈n/2⌉（⌈x⌉表示不小于x的最小整数）个长度为2或者1的有序子序列；再两两归并，……直至得到一个长度为n的有序序列为止。

代码的实现过程：

package com.rhwayfun.algorithm.sort;

/**
 * 归并排序
 * @author Administrator
 *
 */
public class MergeSort2 {

    public void mergeSort(int[] a){
        mSort(a,a,0,a.length - 1);
        for (int i = 0; i < a.length; i++) {
            System.out.println(a[i]);
        }
    }

    private void mSort(int[] b, int[] a, int i, int j) {
        int m = 0;
        int[] c = new int[a.length];
        if(i == j){//递归终止条件
            a[i] = b[i];
        }else {
            m = (i + j)/2;
            //将数组a分为a[i...m]并进行排序
            mSort(b,c,i,m);
            //数组a[m+1...j]部分进行排序
            mSort(b, c, m + 1, j);
            //将a[i...m]部分和a[m+1...j]部分的排序结果归并到a
            merge(c,a,i,m,j);
        }
    }

    private void merge(int[] b, int[] a, int i, int m, int t) {
        int j = 0,k = 0,l = 0;
        for(j = m+1,k = i;i <= m && j<=t;k++){
            //将b中记录由小到大归并到a中
            if(b[i] < b[j]){
                a[k] = b[i++];
            }else {
                a[k] = b[j++];
            }
        }
        //将剩余b[i...m]复制到a中
        if(i<=m){
            for(l=0;l<=m-i;l++){
                a[k+l]=b[i+l];
            }
        }
        //将剩余b[m+1...t]复制到数组a中
        if(j<=t){
            for(l=0;l<=t-j;l++){
                a[k+l]=b[j+l];
            }
        }
    }

    public static void main(String[] args) {
        new MergeSort2().mergeSort(new int[]{50,10,90,30,70,40,80,60,20});
    }
}

以序列{50,10,90,30,70,40,80,60,20}为例，说明归并排序的具体过程：

1. 初始时刻，mSort方法中的数组b和数组a都是{50,10,90,30,70,40,80,60,20}
2. i = 0，j = 9,显然两者不相等，将数组b分为b[i…m]和b[m+1…j]，此时m = 5，也就是数组b 正中间下标
3. 然后递归调用mSort函数，继续将b[0…5]和b[6…9]拆成两组，直到每组只有一个元素
4. 两次递归调用mSort函数之后，b[0…5]和b[6…9]已经排好序了，最后将这两组排好序的数组继续归并成最终排好序的数组，这个过程调用的是merge函数，该函数的主要目的就是将最好的两组进行归并排序
5. 将排好序的数组返回给原数组a，排序结束

由于归并排序在归并过程中需要与原始记录序列同样数量的存储空间存放归并结果以及递归时深度为log2n的栈空间，因此归并排序的空间复杂度是O(n+logn)。

归并排序的总的时间复杂度是O(nlogn)，同时这也是最好、最坏、平均的时间复杂度。需要注意的是，归并排序的是一种稳定的排序算法，但是归并排序是比较占用内存的。

---

转载，原文地址：

http://blog.csdn.net/u011116672/article/details/50119597