猜你不会的前端排序算法全集

• 对于几种前端常见的排序算法，在这里做个总结，希望对大家面试有所帮助 *

1、冒泡排序

• 定义： 对数组的元素（index=i , index=i+1）进行排序，较大的元素放在后面，每次将一个最大的元素放在最后面， 其时间复杂度为O(n^2)

const bubble = (arr) => {
    for(let i = 0; i< arr.length; i++) {
        for (let j=0; j < arr.length -i; j++) {
            if (arr[j] > arr[j+1]) {
                let temp = arr[j+1];
                arr[j+1] = arr[j];
                arr[j] = temp
            }
        }
    }
    return arr
}

2、选择排序

• 定义： 选择排序是每次从待比较的数组中找到最小值，并将该数组的第i个最小值放在数组的第i个位置（对比冒泡排序是找最大值，选择排序是找最小值），该种方式时间复杂度为O(n^2)

const selectSort = (arr) => {
    for(let i=0; i< arr.length -1; i++) {
        let minIndex = i;
        let j = i +1;
        let target = arr[i]
        while(j< arr.length) {
            if (arr[j]< target) {
                minIndex = j;
                target = arr[j]
            }
            j++
        }
        if (minIndex !== i) {
            let temp = arr[minIndex]
            arr[minIndex] =  arr[i]
            arr[i] = temp
        }
    }
    return arr
}

3、插入排序

• 定义：插入排序是对第i(i<=1)个元素和前面的元素进行比较，在该元素<arr[m]时将该元素插入到m-1的位置,该种方式时间复杂度为O(n^2)

const insertSort = (arr) => {
    for(let i=1; i<arr.length; i++) {
        let j = i;
        let target = arr[i]
        while(j > 0 && arr[j-1] > target) {
            arr[j] = arr[j-1]
            j--
        }
        arr[j] = target
    }
    return arr
}

4、归并排序

• 定义： 归并排序使用递归，对数组的一半进行排序，最后再merge，其时间复杂度为O(n*logn)

const merge = (left, right) => {
    let i = 0;
    let j = 0;
    let res = []
    while(i < left.length && j < right.length) {
        if (left[i] < right[j]) {
            res.push(left[i++])
        } else {
            res.push(right[j++])
        }
    }
    if (i < left.length) {
        res.push(...left.slice(i))
    }
    if (j < right.length) {
        res.push(...right.slice(j))
    }
    return res
}

const binarySort = (arr) => {
    if (arr.length < 2) return arr
    let midIndex = Math.floor(arr.length /2)
    let left = binarySort(arr.slice(0, midIndex));
    let right = binarySort(arr.slice(midIndex));
    return merge(left, right)
}

5、快排

• 定义： 快排是先取数组的第一个值，然后比该值小的放在一个数组，比该值大的放在另一个数组，再对这两个数组分别进行递归排序，该种方式时间复杂度为O(n*logn)

const quickSort = (arr) => {
    if (arr.length < 2) return arr
    let base = arr[0];
    let right = [];
    let left = [];
    for (let i=1; i<arr.length; i++) {
        if (arr[i] > base) {
            right.push(arr[i])
        } else {
            left.push(arr[i])
        }
    }
    return [...quickSort(left), base, ...quickSort(right)]
}

6、二分搜索

• 定义： 以数组的 minIndex < maxIndex作为条件，实现二分搜索，其时间复杂度为O(logn)

const binarySearch = (arr, val) => {
    let minIndex = 0;
    let maxIndex = arr.length - 1
    while(minIndex < maxIndex) {
        midIndex = Math.floor((minIndex + maxIndex) /2)
        if (val > arr[maxIndex]) {
            minIndex = midIndex + 1
        } else if (val < arr[minIndex]){
            maxIndex = minIndex -1
        } else {
            return midIndex
        }
    }
    return -1
}