【JavaScript】常见排序算法实现

文章目录

• 冒泡排序
• 选择排序
• 插入排序
• 合并排序
• 快排序

冒泡排序

/*
思路：
每一轮通过比较相邻2个元素之间的大小并按需对调，每一轮将最大或最小的元素排到该轮的尾部。重复N-1次循环后，数组达到有序状态
冒泡排序效率不搞，时间复杂度O(N^2)
*/
const bubbleSort = (array) => {
    const {length} = array
    // n-1 rounds
    for(let n = 1 ; n < length ; n ++ ){
        for(let c = 0 ; c < length - n ; c ++ ){
            // swaps during each round
            if( array[c] > array[c+1] ){
                [array[c],array[c+1]] = [array[c+1],array[c]] 
            }
        }
    }
    return array
}

选择排序

/*
思路：遍历数组每个元素（当前元素），找出其他位置上比当前位置还要小的元素， 与当前元素作对调，O(N^2)
*/
const selectionSort = (array) => {
    const {length} = array
    for(let i = 0; i < length; i ++ ){
        let c = i;
        // current index i, find out the min index c 
        for(let j = i + 1 ; j < length; j ++ ){
            if(array[c]>array[j]){
                c = j
            }
        }
        // swap c and i , i store min value
        if(c != i){
             [array[c],array[i]] = [array[i],array[c]] 
        }
    }
    return array
}

插入排序

/*
思路：将数组前部分当作有序，将数组后部分（无序）的每个元素插入到前面有序的数列中
*/
const insertionSort = (array) => {
    const {length} = array
    let k = 1
    while( k < length  ){
        // unsorted val
        let val = array[k]
        // find out the inserted position c
        let c =  k
        while(c > 0 && array[c-1] > val){
            array[c] = array[c-1]
            c--
        }
        array[c] = val
        k++
    }
    return array
}

合并排序

/*
思路：分治。
将数组平局分成2部分，递归调用合并排序让左右两部分都排好序， 最后合并左右两个有序数组。
*/
const mergeSort = (array) => {
    const {length} = array
    if(length < 2){
        return array
    }
    // divide into 2 arrays
    const mid = ~~(length/2)
    const left = mergeSort(array.slice(0,mid))
    const right = mergeSort(array.slice(mid,length))
    // merge 2 sorted array
    let [l,r] = [0,0]
    let result = []
    while(l < left.length && r < right.length){
        result.push((left[l] < right[r])?left[l++]:right[r++])
    }
    return result.concat(l<left.length?left.slice(l):right.slice(r))
}

快排序

/*
思路：分治。
快排函数：通过分区函数，划分数组成2部分，对2部分分别继续快排
分区函数： 每次将一个数组所有元素 与 某个轴值 作比较，将小于该轴值的所有元素放于该值之前，大于该轴值的元素放于之后。最后确定了轴值在数组的位置，并返回该索引。

*/
const quickSort = (array) => {
    // find the povit
    const partition = (array,left,right) => {
        let pivot = array[~~((left+right)/2)]
        while(left <= right){
            while(array[left] < pivot){
                left ++
            }
            while(array[right] > pivot){
                right --
            }
            if(left <= right){
                [array[left],array[right]] = [array[right],array[left]]
                left ++
                right --
            }
        }
        return left
    }
    // divide 
    const quick = (array,left,right)=>{
        let index = partition(array,left,right)
        if(left < index - 1){
            quick(array,left,index-1)
        }
        if(index < right){
            quick(array,index,right)
        }
        return array
    }
    return quick(array,0,array.length-1)
}