JavaScript 中的常用排序——0607笔记整理

一、冒泡排序

原理： 相邻元素两两对比，根据结果判断是否元素交换。排好顺序往后放，下一次循环只对前边值的进行比对。

    var array = [1, 9, 7, 8, 2, 5, 3, 6, 4];
    function bubbleSort(arr) {
        if (!Array.isArray(arr))return;
        if (arr.length <= 1)return arr;
        var temp = null;
        for (var i = 0; i < arr.length; i++) {
            for (var k = 0; k < arr.length - 1 - i; k++) {
                if (arr[k] > arr[k + 1]) {
                    temp = arr[k];
                    arr[k] = arr[k + 1];
                    arr[k + 1] = temp;
                }
            }
        }
        console.log(arr);   //[1, 2, 3, 4, 5, 6, 7, 8, 9]
    }
    bubbleSort(array);

二、快速排序

原理： 数组折半，和中间值相比较，大小各放一边，使用递归实现。
注意：
（1）截取中间值时，centerNum 可以随机截取数组中任意一个值，不一定是中间索引的值。但是center 中间索引只能写成表达式，不能直接写数字，否则会报错，因为执行递归的过程中left或者right长度不确定，center可能undefined。
（2）取中间值时，得让原数组发生变化。

    var array1 = [1, 9, 7, 8, 2, 5, 3, 6, 4];
    function quickSort(arr) {
        if (!Array.isArray(arr))return;
        if (arr.length <= 1)return arr;
        var center = parseInt(arr.length / 2);  //记录中间索引
        var centerNum = arr.splice(center, 1);  //截取中间值 
        var left = [];
        var right = [];
        for (var i = 0; i < arr.length; i++) {
            if (arr[i] <= centerNum) {
                left.push(arr[i]);
            }
            else {
                right.push(arr[i]);
            }
        }
        //使用递归实现快排
        return quickSort(left).concat(centerNum).concat(quickSort(right));
    }
    console.log(quickSort(array1));

三、插入排序

原理： 默认第一个已排序，取到当前的和之前的对比，满足条件，交换位置。
注意：不能用 if 判断，要用 while。

    var array2 = [1, 9, 7, 8, 2, 5, 3, 6, 4];
    function insertSort(arr) {
        if (!Array.isArray(arr))return;
        if (arr.length <= 1)return arr;
        for (var i = 1; i < arr.length; i++) {
            var nowNum = arr[i];  //记录当前的值
            var preIndex = i - 1;  //记录前边的索引
            while (preIndex >= 0 && arr[preIndex] > nowNum) {
                arr[preIndex + 1] = arr[preIndex];
                preIndex--;
                arr[preIndex + 1] = nowNum;
            }
        }
        console.log(arr);
    }
    insertSort(array2);

四、选择排序

原理： 进for循环，先记录默认最小索引为i，后边的值依次和最小索引的值比对，有满足条件的，替换最小索引，并且两个值交换位置。
由大到小排序同理。

    var array3 = [3, 1, 9, 7, 8, 2, 5, 6, 4];
    function selectSort(arr) {
        if (!Array.isArray(arr))return;
        if (arr.length <= 1)return arr;
        var temp = null;
        for (var i = 0; i < arr.length - 1; i++) {
            var minIndex = i;  //先记录默认的最小索引
            for (var k = i + 1; k < arr.length; k++) {
                //和最小索引的值进行比对  用if判断 或者 三元运算符 都可以
                //minIndex = arr[k] < arr[minIndex] ? k : minIndex;
                if (arr[k] < arr[minIndex]) {
                    minIndex = k;
                }
            }
            temp = arr[i];
            arr[i] = arr[minIndex];
            arr[minIndex] = temp;
        }
        console.log(arr);
    }
    selectSort(array3);

五、归并排序

var array4 = [3, 1, 9, 7, 8, 2, 5, 6, 4];
    function mergeSort(arr) {  // 采用自上而下的递归方法
        if (!Array.isArray(arr))return;
        if (arr.length <= 1)return arr;
        
        var middle = Math.floor(arr.length / 2);
        var left = arr.slice(0, middle);
        var right = arr.slice(middle);
        return merge(mergeSort(left), mergeSort(right));
    }
    console.log(mergeSort(array4));

    function merge(left, right) {
        var result = [];

        while (left.length && right.length) {
            if (left[0] <= right[0]) {
                result.push(left.shift());
            } else {
                result.push(right.shift());
            }
        }

        while (left.length)
            result.push(left.shift());

        while (right.length)
            result.push(right.shift());

        return result;
    }