排序算法（冒泡，选择，插入，归并，快速，计数，基数）--javascript

Array.prototype.BubSort = (arr) => {
    for (let i = 0; i < arr.length - 1; i++) {
        let flag = true;
        for (let j = 0; j < arr.length - i - 1; j++) {
            if (arr[j] > arr[j + 1]) {
                [arr[j], arr[j + 1]] = [arr[j + 1], arr[j]];
                flag = false;
            }
        }
        if (flag) return arr;
        //如果我们通过内部循环完全不交换，这意味着数组已经排序，我们可以在这个点上停止冒泡排序。
    }
    return arr
}

Array.prototype.SelectSort = (arr) => {
    for (var i = 0; i < arr.length-1; i++) {
        var flag = i
        for (var j = i + 1; j < arr.length; j++) {
            if (arr[flag] > arr[j]) {
                flag = j
            }
        }
        var temp = arr[flag]
        arr[flag] = arr[i]
        arr[i] = temp
    }
    return arr
}

Array.prototype.InsSort = (arr) => {
    for (let i = 1; i < arr.length; i++) {
        let temp = arr[i];
        let j = i;
        while (j > 0 && arr[j - 1] > temp) {
            arr[j] = arr[j - 1];
            j--;
        }
        arr[j] = temp;
    }
    return arr
} 

Array.prototype.MerSort = (nums) => {
    let sort = (left, right) => {
        if (left >= right) return;
        let mid = parseInt((right + left) / 2)
        sort(left, mid);
        sort(mid + 1, right);
        merge(left, mid, right);
        return nums;
    }
    let merge = (left, mid, right) => {
        let arr = [];
        let index = 0;
        let i = left, j = mid + 1;
        while (i <= mid && j <= right) {
            arr[index++] = nums[i] < nums[j] ? nums[i++] : nums[j++];
        }
        while (i <= mid) arr[index++] = nums[i++];
        while (j <= right) arr[index++] = nums[j++];
        for (let t = 0; t < index; t++) {
            nums[left + t] = arr[t];
        }
    }
    return sort(0, nums.length - 1);
}

const QuiSort = (array) => {
    const sort = (arr, left = 0, right = arr.length - 1) => {
        if (left >= right) {//如果左边的索引大于等于右边的索引说明整理完毕
            return
        }
        let i = left
        let j = right
        const baseVal = arr[j] // 取无序数组最后一个数为基准值
        while (i < j) {//把所有比基准值小的数放在左边大的数放在右边
            while (i < j && arr[i] <= baseVal) { //找到一个比基准值大的数交换
                i++
            }
            arr[j] = arr[i] // 将较大的值放在右边如果没有比基准值大的数就是将自己赋值给自己（i 等于 j）
            while (j > i && arr[j] >= baseVal) { //找到一个比基准值小的数交换
                j--
            }
            arr[i] = arr[j] // 将较小的值放在左边如果没有找到比基准值小的数就是将自己赋值给自己（i 等于 j）
        }
        arr[j] = baseVal // 将基准值放至中央位置完成一次循环（这时候 j 等于 i ）
        sort(arr, left, j - 1) // 将左边的无序数组重复上面的操作
        sort(arr, j + 1, right) // 将右边的无序数组重复上面的操作
    }
    const newArr = array.concat() // 为了保证这个函数是纯函数拷贝一次数组
    sort(newArr)
    return newArr
}

Array.prototype.CouSort = (arr) => {
    var temp = [];
    arr.map((item)=>{
        temp[item] = ++temp[item] || 1
    })
    arr = []
    temp.map((item , index)=>{
        while(item--){
            arr.push(index)
        }
    })
    return arr
}

Array.prototype.CouSort = (nums) => {
    // 计算位数
    let getDigits = (n) => {
        let sum = 0;
        while (n) {
            sum++;
            n = parseInt(n / 10);
        }
        return sum;
    }
    let arr = Array.from(Array(10)).map(() => Array());
    let max = Math.max(...nums);
    let maxDigits = getDigits(max);
    for (let i = 0, len = nums.length; i < len; i++) {
        // 用0把每一个数都填充成相同的位数
        nums[i] = (nums[i] + '').padStart(maxDigits, 0);
        // 先根据个位数把每一个数放到相应的桶里
        let temp = nums[i][nums[i].length - 1];
        arr[temp].push(nums[i]);
    }
    // 循环判断每个位数
    for (let i = maxDigits - 2; i >= 0; i--) {
        // 循环每一个桶
        for (let j = 0; j <= 9; j++) {
            let temp = arr[j]
            let len = temp.length;
            // 根据当前的位数i把桶里的数放到相应的桶里
            while (len--) {
                let str = temp[0];
                temp.shift();
                arr[str[i]].push(str);
            }
        }
    }
    // 修改回原数组
    let res = [].concat.apply([], arr);
    nums.forEach((val, index) => {
        nums[index] = +res[index];
    })
    return nums
}