前端常用排序算法解析 Algorithm

基本排序算法

1.冒泡排序

通过冒泡的方式比较前后元素大小，逐步完成一一互换，最终实现排序

/* 冒泡排序 */
const  bubbleSort = function (arr) {
    let len = arr.length;
    for (let outer = len; outer >= 2; outer--) {
        for (let inner = 0; inner < outer - 1; inner++) {
            if (arr[inner] > arr[inner + 1]) {
                /* ES6解构赋值 */
                [arr[inner], arr[inner + 1]] = [arr[inner + 1], arr[inner]]
            }
        }
    }
    return arr; 
}

2. 选择排序

选择排序是从数组的开头开始，将第一个元素和其他元素作比较，检查完所有的元素后，最小的放在第一个位置，接下来再开始从第二个元素开始，重复以上一直到最后

/* 选择排序 */
const selectSort = function (arr) {
    let len = arr.length;
    for (let outer = 0; outer < len - 1; outer++) {
        for (let inner = outer; inner < len; inner++) {
            if (arr[inner] < arr[outer]) {
                /* ES6解构赋值 */
                [arr[inner], arr[outer]] = [arr[outer], arr[inner]]
            }
        }
    }
    return arr; 
}

3.插入排序

利用poker牌的思想，拿到一张牌，记住大小，然后再拿到第二张牌和第一张作比较，小的放在左边，再继续拿牌，和前面的牌作比较，同样放在左边，多次之后会形成一个有序的序列…

所以我们:

• 首先将待排序的第一个记录作为一个有序段
• 从第二个开始，到最后一个，依次和前面的有序段进行比较，确定插入位置

/* 插入排序 */
const insertSort = function(arr) {
    let len = arr.length;
    for (let outer = 1; outer < len; outer++) {  //外循环从1开始，默认arr[0]是有序段
        for (let inner = outer; inner > 0; inner--) {
            if (arr[inner] < arr[inner - 1]) {   //inner = outer,将arr[inner]依次插入有序段中
                [arr[inner], arr[inner - 1]] = [arr[inner - 1], arr[inner]]
            } else {     // 因为前边的数组是有序的，所以只需大于有序数组的最后一位即可
                break;
            }
        }
    }
    return arr;
}

4.时间复杂度

排序算法Algorithm	平均时间复杂度	最坏时间复杂度	空间复杂度	是否稳定
冒泡排序	O(n²)	O(n²)	O(1)	是
选择排序	O(n²)	O(n²)	O(1)	不是
插入排序	O(n²)	O(n²)	O(1)	是

高级排序算法

快速排序

1. 选择一个基准元素，将列表分割成两个子序列；
2. 对列表重新排序，将所有小于基准值的元素放在基准值前面，所有大于基准值的元素放在基准值的后面；
3. 分别对较小元素的子序列和较大元素的子序列递归1，2

/* 快速排序 */
const quickSort = function(arr) {
    if (arr.length <=1) {
        return arr; //递归出口
    }
    var left = [],right = [], current = arr.splice(0,1);
    for (let index = 0; index < arr.length; index++) {
       if (arr[index] < current) {
           left.push(arr[index]);
       } else {
           right.push(arr[index]); //放在右边
       }
    }
    return quickSort(left).concat(current, quickSort(right));
}

辅助记忆

时间复杂度记忆

• 冒泡、选择、直接 排序需要两个for循环，每次只关注一个元素，平均时间复杂度为O(n²)(一遍找元素O(n)，一遍找位置O(n)）
• 快速、归并、希尔、堆基于二分思想，log以2为底，平均时间复杂度为O(nlogn)(一遍找元素O(n)，一遍找位置O(logn))

一图胜千言~：

本文部分图片选自net

未完待续中…(0.0）