js归并排序的实现

归并排序的时间复杂度O(N*logN)，额外空间复杂度O(N)

master公式的使用，形如   T(N) = a*T(N/b) + O(N^d) 这样的时间复杂度公式，其复杂度可以化简为：
1) log(b,a) > d -> 复杂度为O(N^log(b,a))

2) log(b,a) = d -> 复杂度为O(N^d * logN)

3) log(b,a) < d -> 复杂度为O(N^d)

 

归并排序递归写法：

function MergeSort(arr) {
    if (!Array.isArray(arr) || arr.length < 2) {
        console.log("传入的数组参数不正确");
        return;
    } 
    mergeSort(arr, 0, arr.length - 1);
}

function  mergeSort(arr, startLeft, startRight) {
    if (startLeft === startRight) {
        return;
    }
    let mid = startLeft + ((startRight - startLeft) >> 1);
    mergeSort(arr, startLeft, mid);
    mergeSort(arr, mid+1,startRight);
    merge(arr, startLeft, mid, startRight);
}

function merge(arr, startLeft, mid, startRight) {
    let help = new Array(startRight - startLeft + 1)
    let i = 0,
        p1 = startLeft,
        p2 = mid + 1;
    while (p1 <= mid && p2 <= startRight) {
        help[i++] = arr[p1] < arr[p2] ? arr[p1++] : arr[p2++];
    }
    while (p1 <= mid) {
        help[i++] = arr[p1++];
    }
    while (p2 <= startRight) {
        help[i++] = arr[p2++];
    }
    for (i = 0; i < help.length; i++) {
        arr[startLeft + i] = help[i]
    }
}
// 以下是对数器和测试代码

function generateRandomArray(maxSize, maxValue) {
    let arr = new Array(Math.floor((maxValue + 1) * Math.random()));
    for (let i = 0; i < arr.length; i++) {
        arr[i] = Math.floor((maxValue + 1) * Math.random()) - Math.floor(maxValue * Math.random());
    }
    return arr;
}

function isEqual(arr1, arr2) {
    if (arr1.length === 0 && arr2.length !== 0) {
        return false;
    }
    if (arr1.length !== 0 && arr2.length === 0) {
        return false;
    }
    if (arr1.length === 0 && arr2.length === 0) {
        return true;
    }
    if (arr1.length !== arr2.length) {
        return false;
    }
    for (let i = 0; i < arr1.length; i++) {
        if (arr1[i] !== arr2[i]) {
            return false;
        }
    }
    return true;
}

let testTime = 50000;
let maxSize = 100,
    maxValue = 100,
    isSucceed = true;
for (let i = 0; i < testTime; i++) {
    let arr1 = generateRandomArray(maxSize, maxValue);
    let arr2 = arr1.slice(0);
    MergeSort(arr1);
    arr2.sort((a,b) => a - b);
    if (!isEqual(arr1, arr2)) {
        isSucceed = false;
        console.log("错误样本如下: ");
        console.log(arr1);
        console.log(arr2);
        break;
    }
}

if (isSucceed) {
    console.log("it works")
} else {
    console.log("falsed");
}

let array = generateRandomArray(maxSize, maxValue);
console.log(array);
MergeSort(array);
console.log(array);

 

非递归写法：分析参考 《数据结构与算法javascript描述》第二版中的自底向上的归并排序分析及实现

/**
 * 采用非递归方法实现javascript归并排序算法
 */

function mergeSort(arr) {
    if (arr.length < 2) {
        return;
    }
    let step = 1;
    let left, right;
    while(step < arr.length) {
        left = 0;
        right = step;
        while(right + step <= arr.length) {
            mergeArrays(arr, left, left+step, right, right+step);
                left = right + step;
                right = left + step;
        }
        if (right < arr.length) {
            mergeArrays(arr,left,left+step, right, arr.length);
        }
        step *= 2;
    }
}


function mergeArrays(arr, startLeft, stopLeft, startRight, stopRight) {
    let rightArr = new Array(stopRight - startRight + 1);
    let leftArr = new Array(stopLeft - startLeft + 1);
    k = startRight;
    for (let i = 0; i < (rightArr.length - 1); ++i) {
        rightArr[i] = arr[k];
        ++k;
    }
    k = startLeft;
    for (let i = 0; i < (leftArr.length - 1); ++i) {
        leftArr[i] = arr[k];
        ++k;
    }
    rightArr[rightArr.length - 1] = Infinity;  // 哨兵值
    leftArr[leftArr.length - 1] = Infinity; // 哨兵值
    let m = 0;
    let n = 0;
    for (let k = startLeft; k < stopRight; ++k) {
        if (leftArr[m] <= rightArr[n]) {
            arr[k] = leftArr[m];
            m++;
        }
        else {
            arr[k] = rightArr[n];
            n++;
        }
    }
    console.log("left array - ", leftArr);
    console.log("right array - ", rightArr);
}

let nums = [6,10,1,9,4,8,2,7,3,5];
console.log(nums);
console.log("---------------");
mergeSort(nums)
console.log(nums);

实际运用：

小数问题的解决：在一个数组中，每一个数左边比当前数小的数累加起来，叫做这个数组的小和。求一个数组 的小和。

比如：

对于数组  [1,3,4,2,5]

    1左边比1小的数，没有；

    3左边比3小的数，1；

    4左边比4小的数，1、3；

    2左边比2小的数，1；

    5左边比5小的数，1、3、4、2；

所以小和为1+1+3+1+1+3+4+2=16

 

采用每次都遍历一下数组各个位置上的元素然后找出比当前小的元素，然后逐个相加可以得到小和，时间复杂度为O(N*N)

采用归并排序的方法显然更快：

let res1 = 0,
    res2 = 0;
function smallSum(arr) {
    if (arr.length < 2) {
        return 0;
    }
    return mergeSort(arr, 0, arr.length - 1);
}

function mergeSort(arr, left, right) {
    if (left === right) {
        return 0;
    }
    let mid = left + ((right - left) >> 1);
    return mergeSort(arr, left, mid) + mergeSort(arr, mid+1, right) + merge(arr, left, mid, right);
}

function merge(arr, left, mid, right) {
    let help = new Array(right - left + 1);  // help为辅助数组,大小为参数数组的大小

    /*
    * p1 为左边的数组的移动标，可以理解为指针， p2则为右边的数组的移动指标
    * res 接收数组的小和
    * */
    let i = 0,
        p1 = left,
        p2 = mid + 1;

    while (p1 <= mid && p2 <= right) {
        res1 += arr[p1] < arr[p2] ? (right - p2 + 1) * arr[p1] : 0;
        help[i++] = arr[p1] < arr[p2] ? arr[p1++] : arr[p2++];
    }
    while (p1 <= mid) {
        help[i++] = arr[p1++];
    }
    while (p2 <= right) {
        help[i++] = arr[p2++];
    }
    for (let i = 0; i < help.length; i++) {
        arr[left + i] = help[i];
    }
    return res1;
}

function  comparator (arr) {
    if (arr.length < 2) {
        return;
    }

    for (let i = 1; i < arr.length; i++) {
        for (j = 0; j < i; j++) {
            res2 += arr[j] < arr[i] ? arr[j] : 0;
        }
    }
    return res2;
}


// 以下代码是数组随机生成器 及测试代码
function generateRandomArray(maxSize, maxValue) {
    let arr = new Array(Math.floor((maxSize + 1) * Math.random()));
    for (let i = 0; i < arr.length; i++) {
        arr[i] = Math.floor((maxValue + 1) * Math.random()) - Math.floor(maxValue * Math.random());
    }
    return arr;
}

// function isEqual(arr1, arr2) {
// //     if (arr1.length !== 0 && arr2.length === 0) {
// //         return false;
// //     }
// //     if (arr1.length === 0 && arr2.length !== 0) {
// //         return false;
// //     }
// //     if (arr1.length === 0 && arr2.length === 0) {
// //         return true;
// //     }
// //     if (arr1.length !== arr2.length) {
// //         return false;
// //     }
// //     for (let i = 0; i < arr1.length; i++) {
// //         if (arr1[i] !== arr2[i]) {
// //             return false;
// //         }
// //     }
// //     return true;
// // }


// 测试样本
// let array = [1,3,4,2,5];
// let array2 = [1,3,4,2,5];
// smallSum(array);
// comparator(array2)
// console.log(res1);
// console.log(res2);

let testTime = 50000;
let maxSize = 10;
let maxValue = 10;
let succeed = true;

for (let i = 0; i < testTime; i++) {
    let arr1 = generateRandomArray(maxSize, maxValue);
    let arr2 = JSON.parse(JSON.stringify(arr1));
    smallSum(arr1);
    console.log(res1);
    comparator(arr2);
    console.log(res2);

    if (res1 !== res2) {
        succeed = false;
        console.log("归并排序数组: " + arr1);
        console.log("遍历得到的数组: " + arr2);
        break;
    }
}

if (succeed) {
    console.log("it works!");
} else {
    console.log("falsed");
}