js实现常见排序算法

/**
     * 冒泡排序
     * 相邻元素比较，大的往后放
     * 每趟排完，最大元素位置已经排好
     */

    function buble(arr) {
        // 需要排序n-1趟
        for (var i = 0; i < arr.length - 1; i++) {
            for (var j = 0; j < arr.length - i - 1; j++) {
                // 碰到前面比后面大的数，进行交换
                if (arr[j] > arr[j + 1]) {
                    var temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
        }
        return arr
    }


    /**
     * 选择排序
     * 每趟找到最小元素，与前面排好序的最后一位交换
     */

    function selectSort(arr) {
        //保存每次排序最小的索引
        var minIndex = null; 
        for (var i = 0; i < arr.length - 1; i++) {
            minIndex = i;
            for (var j = i + 1; j < arr.length; j++) {
                if (arr[j] < arr[minIndex]) {
                    var temp = arr[minIndex];
                    arr[minIndex] = arr[j];
                    arr[j] = temp;
                }
            }
        }
        return arr;
    }


    /**
     * 插入排序
     * 从arr[1]开始，与前面元素相比
     * 小的往前放，大的往后放
     */

    function insertSort(arr) {
        var len = arr.length;
        for (var i = 1; i < len; i++) {
            // 待插元素
            var item = arr[i];
            //排序后的末尾元素
            var j = i - 1;
            // 从排序好的末尾元素开始遍历
            // 如果大于待插元素就把当前元素往后挪
            while (j >= 0 && arr[j] > item) {
                arr[j + 1] = arr[j];
                j--;
            }
            // 插入待插元素
            arr[j + 1] = item;
        }
        return arr;
    }


    /**
     * 快速排序
     * 网上某大神的写法
     * 重新开辟空间递归排序
     */

    function quickSort(arr) {
        if (arr.length <= 1) {
            return arr;
        }
        var middleIndex = Math.floor(arr.length / 2);
        var middleItem = arr.splice(middleIndex, 1)[0];
        var left = [];
        var right = [];
        for (var i = 0; i < arr.length; i++) {
            if (middleItem > arr[i]) {
                left.push(arr[i])
            } else {
                right.push(arr[i])
            }
        }

        return quickSort(left).concat(middleItem, quickSort(right))
    }

    
    /**
     * 快速排序原地排序
     * 转自https://www.jianshu.com/p/2f542730ebe6
     */
    function quickSort(arr, left, right) {

        // 如果左边界比右边界大，返回结果，排序结束
        if (left > right) {
            return;
        }

        // 默认值处理，如果有传入left和right参数，就赋值这个参数，否则就赋值后面的默认值
        left = left || 0;
        right = right || arr.length - 1;

        // 定义移动的左游标和右游标
        var leftPoint = left;
        var rightPoint = right;

        // 定义一个基准数
        var temp = arr[left];

        // 判断左右游标是否重合，如果重合，循环结束
        while (leftPoint != rightPoint) {

            // 基准数在左边，因此从右边开始一个个扫描
            // 从右到左，寻找小于基准数的数，且左游标要小于右游标
            // 如果数字大于基准数（证明不符合条件），寻找下一个
            // 直到找到比基准数小的数，游标停止递减
            while (arr[rightPoint] >= temp && leftPoint < rightPoint) {
                rightPoint--;
            }
            // 从左到右，寻找大于基准数的数，且左游标要小于右游标
            // 如果数字小于基准数（证明不符合条件），寻找下一个
            // 直到找到比基准数小的数，游标停止递增
            while (arr[leftPoint] <= temp && leftPoint < rightPoint) {
                leftPoint++;
            }

            // 如果左游标小于右游标，则交换两个数字的位置
            if (leftPoint < rightPoint) {
                var changeNumber = arr[leftPoint];
                arr[leftPoint] = arr[rightPoint];
                arr[rightPoint] = changeNumber;
            }
            // 进行下一次循环，直到两个游标重合位置
        }

        // 重合之后，交换基准数
        arr[left] = arr[leftPoint];
        arr[leftPoint] = temp;

        // 递归操作左右两个数组
        quickSort(arr, left, leftPoint - 1);
        quickSort(arr, leftPoint + 1, right);

        return arr;
    };



    /**
     * 归并排序 
     * 一直把数组递归到单个元素成有序数组，然后合并
     */


    function mergeSort(arr) {
        var len = arr.length

        if (len <= 1) {
            return arr;
        }

        var mid = Math.floor(len / 2);

        var left = arr.slice(0, mid);
        var right = arr.slice(mid)

        return merge(mergeSort(left), mergeSort(right))
    }

    function merge(left, right) {
        var result = [];
        // 设置左右移动变量
        var i = 0,
            j = 0;
        // 每次拿left和right数组的头元素做比较
        while (i < left.length && j < right.length) {
            if (left[i] > right[j]) {
                result.push(right[j])
                j++
            } else {
                result.push(left[i]);
                i++;
            }
        }

        while (i < left.length) {
            result.push(left[i]);
            i++;
        }

        while (j < right.length) {
            result.push(right[j]);
            j++;
        }
        return result;
    }

    /**
     * 希尔排序
     * 类似插入排序，不过多了增量，不再是相邻比较
     * 初始增量为长度一半，依次折半
     */


    function shellSort(arr) {
        var len = arr.length;

        for (var gap = Math.floor(len / 2); gap > 0; gap = Math.floor(gap / 2)) {
            for (var i = gap; i < len; i++) {
                var j = i - gap;
                var item = arr[i]
                while (j >= 0 && arr[j] > item) {
                    arr[j + gap] = arr[j];
                    j -= gap;
                }
                arr[j + gap] = item
            }
        }
        return arr;
    }