数据结构与算法之排序(归纳总结四)-技术方案-@大数据资讯

1.算法描述

　　归并排序的基本思想是基于合并操作，即合并两个已经有序的序列是容易的，不论这两个序列是顺序存储还是链式存储，合并操作都可以在Ο(m+n)时间内完成（假设两个有序表的长度分别为m和n）。为此，由分治法的一般设计步骤得到归并排序的过程为：
　　1. 划分：将待排序的序列划分为大小相等（或大致相等）的两个子序列；
　　2. 治理：当子序列的规模大于1时，递归排序子序列，如果子序列规模为1则成为有序序列；
　　3. 组合：将两个有序的子序列合并为一个有序序列。

2.算法实现

归并的核心在于除了每个子列的排序外还有就是将前后两个相邻的有序序列合并。下面给出实现的算法

private void merge(int[] a, int p, int q, int r) {
    int[] b = new int[r - p + 1];
    int s = p;
    int t = q + 1;
    int k = 0;
    while (s <= q && t <= r)
        if (compare(a[s], a[t]))
            b[k++] = a[s++];
        else
 
            b[k++] = a[t++];
    while (s <= q)
        b[k++] = a[s++];
    while (t <= r)
        b[k++] = a[t++];
    for (int i = 0; i < b.length; i++)
        a[p + i] = b[i];
}
 
public void mergeSort(int[] r, int low, int high) {
    if (low < high) {
        mergeSort(r, low, (high + low) / 2);
        mergeSort(r, (high + low) / 2 + 1, high);
        merge(r, low, (high + low) / 2, high);
    }
}

【效率分析】
空间效率：在归并排序中，为了将子序列合并需要使用额外的存储空间，这个辅助存储空间的最大值不超过n，因此归并算法的空间复杂度为Θ(n)。
时间效率：归并算法是一个典型的分治算法，时间复杂度为 Ο(n log n)。

　3.算法示例

MergeSort.java

package com.test.sort.merge;
 
 
public class MergeSort {
 
    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
 
        System.out.println("归并排序排序功能实现》》》》");
        int[] arr = { 23, 54, 6, 2, 65, 34, 2, 67, 7, 9, 43 };
 
        MergeSort sort = new MergeSort();
        System.out.println("排序之前序列：");
        sort.printArr(arr);
        sort.mergeSort(arr, 0, arr.length - 1);
        System.out.println("排序之后序列：");;
        sort.printArr(arr);
    }
 
    private void merge(int[] a, int p, int q, int r) {
        int[] b = new int[r - p + 1];
        int s = p;
        int t = q + 1;
        int k = 0;
        while (s <= q && t <= r)
            if (compare(a[s], a[t]))
                b[k++] = a[s++];
            else
 
                b[k++] = a[t++];
        while (s <= q)
            b[k++] = a[s++];
        while (t <= r)
            b[k++] = a[t++];
        for (int i = 0; i < b.length; i++)
            a[p + i] = b[i];
    }
 
    public void mergeSort(int[] r, int low, int high) {
        if (low < high) {
            mergeSort(r, low, (high + low) / 2);
            mergeSort(r, (high + low) / 2 + 1, high);
            merge(r, low, (high + low) / 2, high);
        }
    }
 
    public boolean compare(int paramA, int paramB) {
        if (paramA < paramB) {
            return true;
        } else {
            return false;
        }
    }
 
    /**
     * 依次打印出数组元素
     */
    public void printArr(int[] arr) {
        if (arr != null) {
            for (int temp : arr) {
                System.out.print(temp + "  ");
            }
            System.out.println();
        }
    }
}

　　4.结果输出

原文链接：http://www.cnblogs.com/zhangminghui/p/4181144.html