js常见排序算法总结

冒泡排序

function bubbleSort(arr){
    let len = arr.length
    for(let i = 0; i <= len-1;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 selectSort(arr){
    let len = arr.length
    for(let i = 0;i <= len -1;i++){
        for(let j = i;j <= len -1 ;j++){
            if(arr[j] < arr[i]){
                [arr[j],arr[i]] = [arr[i],arr[j]]
            }
        }

    }
    return arr
}

插入排序

插入排序思想的核心 局部有序（部分有序）

• i 从1 开始，拿到当前数，与前面的数进行比较
• 第二层循环j从1开始，假设前面i-1个都是有序的，进行判断，如果前面的数大于当前的数，那么就进行交换,。
• 直到未排序的数没有了，那么排序就结束。

function insertSort(arr){
    for(var i = 1; i < arr.length; i++){
        for(var j = i; j > 0 ;j--){
            if(arr[j-1] > arr[j]){
                [arr[j-1],arr[j]] = [arr[j],arr[j-1]]
            }else if(arr[j-1] <= arr[j]){
                break
            }
        }
    }
    return arr
}

快速排序

思想：“分而治之”，

• 将比参考值小的放在左边，将参考值大的放在右边
• 对左边的进行递归，直到数组的长度为1 平均时间复杂度是O(nlogn)，最差时间复杂度是O(n^2)

function quickSort(arr){
    if(arr.length == 1){
        return arr
    }
    let left = 0
    let right = arr.length-1
    let arrLeft = []
    let arrRight = []
    let pivotIndex = (left + right)>>>1
    let pivot = arr.splice(pivotIndex,1)[0]
    // let pivot = arr.splice(pivotIndex,1)也可以
    //此处的splice返回的数组因为只有一个值可以直接与下面的数做比较
    //例如：1<[2]//true 0 < [1,3]// false 0 < [1,3][0] //true
    for(let i = 0; i < arr.length;i++){
        if(arr[i] <= pivot){
            arrLeft.push(arr[i])
        }else{
            arrRight.push(arr[i])
        }
    }
    return quickSort(arrLeft).concat(pivot,...quickSort([arrRight]))
}

使用指针交换位置来实现

function quickSortzz(arr){
    function quick(arr,begin,end){
        if(begin >= end){
            return
        }
        let pivot = arr[begin]//将最左边的作为参考点
        let left = begin
        let right = end
        while(left < right){
            while(arr[right] >= pivot && left < right){
                right--
            }
            while(arr[left] <= pivot && left < right){
                left++
            }
            [arr[left],arr[right]] = [arr[right],arr[left]]
        }
        [arr[begin],arr[left]] = [arr[left],arr[begin]]
        quick(arr,begin,left-1)
        quick(arr,left+1,end)
    }
    quick(arr,0,arr.length-1)
    return arr
}