归并排序算法

归并排序（Merge sort，台湾译作：合并排序）是建立在归并操作上的一种有效的排序算法。该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。

归并排序算法稳定，数组需要O(n)的额外空间，链表需要O(log(n))的额外空间，时间复杂度为O(nlog(n))，算法不是自适应的，不需要对数据的随机读取。

• 时间复杂度
  
  • 平均情况 ：O( nlog2n)
  • 最好情况 ：O( nlog2n)
  • 最坏情况 ：O( nlog2n)
• 空间复杂度
  
  • O(1)
• 稳定性
  
  • 稳定

算法步骤：

1. 申请空间，使其大小为两个已经排序序列之和，该空间用来存放合并后的序列
2. 设定两个指针，最初位置分别为两个已经排序序列的起始位置
3. 比较两个指针所指向的元素，选择相对小的元素放入到合并空间，并移动指针到下一位置
4. 重复步骤3直到某一指针达到序列尾
5. 将另一序列剩下的所有元素直接复制到合并序列尾

算法原理

归并排序具体工作原理如下（假设序列共有n个元素）：

• 将序列每相邻两个数字进行归并操作（merge)，形成floor(n/2)个序列，排序后每个序列包含两个元素
• 将上述序列再次归并，形成floor(n/4)个序列，每个序列包含四个元素
• 重复步骤2，直到所有元素排序完毕
  归并排序是稳定的排序算法，其时间复杂度为O(nlogn)，如果是使用链表的实现的话，空间复杂度可以达到O(1)，但如果是使用数组来存储数据的话，在归并的过程中，需要临时空间来存储归并好的数据，所以空间复杂度为O(n)

javascript

function merge(left,right){
                    var re=[];
                    while(left.length>0 && right.length>0){
                        if(left[0]<right[0]){
                            re.push(left.shift());
                        }else{
                            re.push(right.shift());
                        }
                    }
                    return re.concat(left).concat(right);
                }
                function mergeSortT(array){
                    if(array.length==1)return array;
                     /* 首先将无序数组划分为两个数组 */
                    var mid=Math.floor(array.length/2);
                    var left=array.slice(0,mid);
                    var right=array.slice(mid);
                    /* 递归分别对左右两部分数组进行排序合并 */
                     return merge(mergeSortT(left), mergeSortT(right));
                }
                alert(mergeSortT([32,45,37,16,2,87]));

Java

/**
*将两个数组进行归并，归并前面2个数组已有序，归并后依然有序
*@param data  数组对象 
*@param left 左数组的第一个元素的索引 
*@param center 左数组的最后一个元素的索引，center+1是右数组第一个元素的索引 
*@param right  右数组最后一个元素的索引 
**/
public static void merge(int[] data,int left,int center,int right){
    //临时数组
    int[] tmpArr=new int[data.lenght];
     // 右数组第一个元素索引
    int mid=center+1;
    // third 记录临时数组的索引  
        int third = left;  
        // 缓存左数组第一个元素的索引  
        int tmp = left;  
        while (left <= center && mid <= right) {  
            // 从两个数组中取出最小的放入临时数组  
            if (data[left] <= data[mid]) {  
                tmpArr[third++] = data[left++];  
            } else {  
                tmpArr[third++] = data[mid++];  
            }  
        }  
        // 剩余部分依次放入临时数组（实际上两个while只会执行其中一个）  
        while (mid <= right) {  
            tmpArr[third++] = data[mid++];  
        }  
        while (left <= center) {  
            tmpArr[third++] = data[left++];  
        }  
        // 将临时数组中的内容拷贝回原数组中  
        // （原left-right范围的内容被复制回原数组）  
        while (tmp <= right) {  
            data[tmp] = tmpArr[tmp++];  
        }  
}
public static void print(int[] data) {  
        for (int i = 0; i < data.length; i++) {  
            System.out.print(data[i] + "\t");  
        }  
        System.out.println();  
    }  
  public static void sort(int[] data, int left, int right) {  
        if (left >= right) return;  
        // 找出中间索引  
        int center = (left + right) / 2;  
        // 对左边数组进行递归  
        sort(data, left, center);  
        // 对右边数组进行递归  
        sort(data, center + 1, right);  
        // 合并  
        merge(data, left, center, right);  
        print(data);  
    }  
  public static void mergeSort(int[] data) {  
        sort(data, 0, data.length - 1);  
    }  
  public class MergeSortTest {  

    public static void main(String[] args) {  
        int[] data = new int[] { 32,45,37,16,2,87};  
        print(data);  
        mergeSort(data);  
        System.out.println("排序后的数组：");  
        print(data);  
    }