归并排序

　　归并排序是一种借助"归并"进行排序的方法，归并的含义是将两个或者两个以上的有序序列归并成一个有序序列的过程。主要是思想是将若干有序序列逐步归并，最终归并为一个有序序列。

　　二路归并排序是归并排序中最简单的排序方法，基本思想是将若干个有序序列进行两两归并，直至所有待排序记录都在一个有序序列为止。

递归实现：

//source源数组,dest目标数组,first起始下标,last目标下标
function mergeSort2(source, dest ,first, last) {
    // var dest = [];
    if (first == last) {
        dest[first] = source[first];
    } else {
        //var mid = (first + last) >>> 1; //求中位数 
        var mid = Math.floor((first + last) / 2);
        mergeSort(source, dest, first, mid);
        mergeSort(source, dest, mid + 1, last);
        merge(dest, source, first, mid, last);
    }
    console.log(source);
    // return source;
}

//将两个数组按照从小到大的顺序融合,source原数组,dest排序后的数组,s第一个下标,m第二个数组下标
function merge(source, dest, s, m, t) {
    var i = s,
        j = m + 1,
        k = s;
    //当两个带归并的有序序列都没有进行到尾部时，执行操作
    while (i <= m && j <= t) {
        //取source[i]和source[j]中的较小者存入dest[k]
        if (source[i] <= source[j]) {
            dest[k++] = source[i++];
        } else {
            dest[k++] = source[j++];
        }
    }
    //若第一个子序列没有处理完，则进行收尾处理
    if (i <= m) {
        while (i <= m) {
            dest[k++] = source[i++];
        }
    } else {
        while (j <= t) {
            dest[k++] = source[j++];
        }
    }
    for (i = 0; i < source.length; i++) {
        source[i] = dest[i];
    }
    return source;
}
// merge([20,60,10,50],[],0,1,3);
mergeSort([8,3,2,6,7,1,5,4],[],0,7);

效率：

时间复杂度：最好：O(nlog2n)，最坏：O(nlog2n)，平均：O(nlog2n)。

空间复杂度：O(n)。

稳定性：稳定

非递归实现：

/*归并排序非递归实现*/
//将两个数组按照从小到大的顺序融合,source原数组,dest排序后的数组,s第一个下标,m第二个数组下标 一次归并算法
function merge(source, dest, s, m, t) {
    var i = s,
        j = m + 1,
        k = s;
    //当两个带归并的有序序列都没有进行到尾部时，执行操作
    while (i <= m && j <= t) {
        //取source[i]和source[j]中的较小者存入dest[k]
        if (source[i] <= source[j]) {
            dest[k++] = source[i++];
        } else {
            dest[k++] = source[j++];
        }
    }
    //若第一个子序列没有处理完，则进行收尾处理
    if (i <= m) {
        while (i <= m) {
            dest[k++] = source[i++];
        }
    } else {
        while (j <= t) {
            dest[k++] = source[j++];
        }
    }
    for (i = 0; i < dest.length; i++) {
        source[i] = dest[i];
    }
    // return source;
}
//一趟归并排序
function mergePass(sourcem, destm ,n, h) {//从下标1开始存放待排序序列
    var i=0;
    while(i<=n-2*h+1){//待归并的记录至少有两个长度为h的子序列
        merge(sourcem,destm,i,i+h-1,i+2*h-1);//合并
        i+=2*h;
    }
    if(i<n-h+1){//待归并记录至少有一个长度为h
        merge(sourcem,destm,i,i+h-1,n);
    }else {//待归并记录只剩一个子序列
        for(var k=i;k<=n;k++) {
            destm[k]=sourcem[k];
        }
    }
}
function mergeSort2(source,dest,n){
    var h=1;
    while(h<n) {
        mergePass(source,dest,n,h);//待排序序列从数组source中传递到dest中
        h=2*h;
        mergePass(dest,source,n,h);//待排序序列从数组dest中传递到source中
        h=2*h;
    }
    return dest;
}
// merge([20,60,10,50],[],0,1,3);
mergeSort2([60,20,10,50,15,30,55],[],6);

效率：

时间复杂度：最好：O(nlog2n)，最坏：O(nlog2n)，平均：O(nlog2n)。

空间复杂度：O(n)。

稳定性：稳定