归并排序 —— 面试最常考的手写算法之三

归并排序的核心思想：分治。
分治法是将原问题分解为几个规模较小但类似原问题的子问题，递归的求解这些子问题，然后合并这些子问题的解来建立原问题的解。 归并排序适合解决数据量较大的问题，相比其他排序，性能较好。

算法思路

• 分区：把数组劈成两半，再递归的对子数组进行“分”操作，直到分成一个个单独的数；
• 合并：把两个数合并为有序数组，再对有序数组进行合并，直到全部子数组合并为一个数组；

步骤

1、把数组一分为二；
2、递归左；
3、递归右；
4、对递归的结果进行排序。

时间复杂度

分区的时间复杂度 O(logN)
合并的时间复杂度 O(n)
时间复杂度O(n*logN)

Coding

Array.prototype.mergeSort = function(){
    const rec = (arr) => { //rec递归
        if(arr.length === 1) return arr;
        const mid = Math.floor(arr.length / 2);
        const left = arr.slice(0,mid); //截取0-mid间的元素
        const right = arr.slice(mid,arr.length);
        const orderLeft = rec(left);
        const orderRight = rec(right);
        const res = [];
        while(orderLeft.length || orderRight.length){
            if(orderLeft.length && orderRight.length){
                res.push(orderLeft[0] < orderRight[0] ? orderLeft.shift() : orderRight.shift()) //shift()删除数组第一个元素并返回
            }else if(orderLeft.length){
                res.push(orderLeft.shift());
            }else if(orderRight.length){
                res.push(orderRight.shift());
            }
        }
        return res;
    }
    const res = rec(this);
    res.forEach((n,i) => { this[i] = n; })
}

const arr = [5,4,3,2,1]
arr.mergeSort(); //arr = [1,2,3,4,5]

简洁写法

function mergeSort(arr){
    if(arr.length < 2) return arr

    let mid = Math.floor(arr.length / 2)
    let left = arr.slice(0,mid) //slice选择元素 从0开始，到mid结束，但不包括mid
    let right = arr.slice(mid)
    let leftOrder = mergeSort(left)
    let rightOrder = mergeSort(right)

    let res = []
    while(leftOrder.length || rightOrder.length){
        if(leftOrder.length && rightOrder.length){
            res.push(leftOrder[0] < rightOrder[0] ? leftOrder.shift() : rightOrder.shift())
        }else if(leftOrder.length){
            res.push(leftOrder.shift())
        }else if(rightOrder.length){
            res.push(rightOrder.shift())
        }
    }
    return res
}

let res2 = mergeSort([3,2,1])

需要注意的点：
array.slice(start,end) 选择元素，从start开始，到end结束，但不包括end，end可以不写，默认到数组最后一个元素。
递归是自身调用，要加结束条件。