js排序算法

1.冒泡排序

平均时间复杂度O(n*n)    最好情况O(n)    最差情况O(n*n)     空间复杂度O(1)    稳定性：稳定

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
}

2.选择排序

平均时间复杂度O(n*n)    最好情况O(n*n)    最差情况O(n*n)     空间复杂度O(1)    稳定性：不稳定

function select(arr){
    let len = arr.length
    for(let i = 0; i < len-1; i++){
        let min = i //定位一个数
        // 找出该索引后更小的数进行交换
        for(let j = i+1; j < len; j++){
            if(arr[j] < arr[min]) min = j
        }
        [arr[i], arr[min]] = [arr[min], arr[i]]
    }
    return arr
}

3.快速排序  分治法

平均时间复杂度O(nlogn)    最好情况O(nlogn)    最差情况O(n*n)     空间复杂度O(nlogn)    稳定性：不稳定

// 分治法 递归实现
function fastSort(arr){
    if(arr.length <= 1) return arr
    let temp = arr[0]
    let left = [],right = []
    for(let i = 1; i < arr.length; i++){
        if(arr[i] >= temp){
            right.push(arr[i])
        }else{
            left.push(arr[i])
        }
    }
    return fastSort(left).concat(temp, fastSort(right))
}

4.归并排序 分治法

平均时间复杂度O(nlogn)    最好情况O(nlogn)    最差情况O(nlogn)     空间复杂度O(n)    稳定性：稳定

function divide(arr){
    if(arr.length <=1) return arr
    let middle = Math.floor(arr.length / 2)
    let left = arr.slice(0, middle)
    let right = arr.slice(middle)
    return merge(divide(left), divide(right))
}
function merge(left, right){
    let res = []
    while(left.length && right.length){
        if(left[0] <= right[0]){
            res.push(left.shift())
        }else{
            res.push(right.shift())
        }
    }
    while(left.length){
        res.push(left.shift())
    }
    while(right.length){
        res.push(right.shift())
    }
    return res
}

5.插入排序 

平均时间复杂度O(n²)    最好情况O(n)    最差情况O(n²)     空间复杂度O(1)    稳定性：稳定

function sort(arr){
    let len = arr.length
    for(let i = 1; i < len; i++){
        for(let j = i-1; j>=0 && arr[j] > arr[j+1]; j--){
            [arr[j+1], arr[j]] = [arr[j], arr[j+1]] // 交换位置
        }
    }
    return arr
}

6.希尔排序 插入排序法的改进

平均时间复杂度O(nlogn)    最好情况O(nlog²n)    最差情况O(nlog²n)     空间复杂度O(1)    稳定性：不稳定

function sort(arr){
    let len = arr.length
    for(let gap = Math.floor(len/2); gap > 0; gap = Math.floor(gap/2)){
        // 插入排序 跨度为gap
        for(let i = gap; i < len; i++){
            for(let j = i-gap; j>=0 && arr[j] > arr[j+gap]; j-=gap){
                [arr[j+gap], arr[j]] = [arr[j], arr[j+gap]]
            }
        }
    }
    return arr
}