冒泡排序

function bubbleSort (arr) {
    let len = arr.length;
    for(let i=0; i<len; i++) {
        for(let j=0; j<len-1-i;j++) {
            if(arr[j]>arr[j+1]) {
                [arr[j],arr[j+1]] = [arr[j+1], arr[j]];
            }
        }
    }
    return arr;
}

插入排序

/**双层循环，外循环控制未排序的元素，内循环控制已排序的元素，将未排序元素设为标杆，
与已排序的元素进行比较，小于则交换位置，大于则位置不动
*/
function insertSort(arr) {
    let tem
    for(let i=0; i<arr.length; i++) {
        tem = arr[i]
        for(let j=i; j>=0; j--){
            if(arr[j-1] > tem){
                arr[j] = arr[j-1]
            }else {
                arr[j] = tem
                break
            }
        }
    }
    return arr
}

快速排序

function quickSort (arr) {
    let len=arr.length,left=[],right=[],current = arr[0];
    if(len<=1) return arr;
    for(let i=1; i<len; i++){
        if(arr[i]<current) {
            left.push(arr[i]);
        } else {
            right.push(arr[i])
        }   
    }
    // 递归步骤1，2
    return quickSort(left).concat(current, quickSort(right))
}

选择排序

/**
 * 先假设第一个元素为最小的，然后通过循环找出最小元素，
 * 然后同第一个元素交换，接着假设第二个元素，重复上述操作即可
 */
function selectSort(arr) {
    let len = arr.length, minIndex, tem
    for(let i=0; i<len-1; i++) {
        minIndex = i //最小值下标
        for(let j=i+1; j<len; j++) {
            if(arr[j] < arr[minIndex]){
                // 找出最小值
                minIndex = j //更换最小值下标
            }
        }
        // 交换位置
        tem = arr[i]
        arr[i] = arr[minIndex]
        arr[minIndex] = tem
    }
    return arr
}

归并排序

// 将数组一直等分，然后合并
function merge(left, right) {
    let tem = [];
    while(left.length && right.length) {
        if(left[0] < right[0]) {
            tem.push(left.shift());
        }else{
            tem.push(right.shift());
        }
    }
    return tem.concat(left,right);
}
function mergeSort(arr) {
    const len = arr.length;
    if(len<2) return arr;
    let mid = Math.floor(len / 2), left = arr.slice(0,mid), right = arr.slice(mid);
    return merge(mergeSort(left),mergeSort(right));
}

希尔排序

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;
            var current = arr[i];
            while (j - gap >= 0 && current < arr[j - gap]) {
                 arr[j] = arr[j - gap];
                 j = j - gap;
            }
            arr[j] = current;
        }
    }
    return arr;
}