你需要知道得几种排序方法

冒泡排序

function bubbleSort(arr) {
    // 缓存数组长度
    const len = arr.length;
    // 外层循环用于控制从头到尾得比较+交换到底有多少轮
    for(let i = 0; i <len -1;i ++) {
        // 内存循环用于完成每一轮遍历过程中得重复比较 + 交换
        for(let j = 0;j<len -1;j++) {
        // 若相邻元素前面得数比后面得大
        if(arr[j] > arr[j+1]) {
            // 交换二者
            [arr[j],arr[j+1]] = [arr[j+1],arr[j]];
        }
      }
    }
    // 返回数组
    return arr;
}

选择排序

function selectSort(arr) {
    // 缓存数组长度
    const len = arr.length;
    // 定义 minIndex,缓存当前区间最小值的索引，注意是索引
    let minIndex;
    // i 是当前排序区间的起点
    for(let i = 0; i < len -1;i ++) {
        //  初始化minIndex为当前区间第一个元素
        minIndex = i;
        // i,j分别定义当前区间的上下界,i是左边界,j是右边界
        for(let j = i;j < len;j++) {
            // 若j处的数据项比当前最小值还要小，则更新最小值索引为j
            if(arr[[j] < arr[minIndex]]) {
                minIndex = j;
            }
        }
        // 如果minIndex对应元素不是目前的头部元素，则交换2者
        if(minIndex !==i ) {
            [arr[i],arr[minIndex]] = [arr[minIndex],arr[i]];
        }
    }
    return arr;
}

快速排序

function quickSort(arr) {
    if(arr.length < 2) {
        return arr;
    }
    const cur = arr[arr.length - 1];
    const left = arr.filter((v,i) => v <= cur && i !== arr.length - 1) ;
    const right = arr.filter((v) => v > cur);
    return [...quickSort(left),cur,...quickSort(right)];
}

归并排序

function merge(left,right) {
    let res = [];
    let i = 0;
    let j = 0;
    while(i < left.length && j < right.length) {
        if(left[i] < right[j]) {
            res.push(left[i]);
            i++;
        } else {
            res.push(right[j]);
            j++;
        }
    } 
    if(i < left.length) {
        res.push(...left.slice(i));
    } else  {
        res.push(...right.slice(j));
    }
    return res;
}
function mergeSort(arr) {
    if(arr.length < 2) {
        return arr;
    }
    const mid = Math.floor(arr.length / 2 );
    const left = mergeSort(arr.slice(0,mid));
    const right = mergeSort(arr.slice(mid));
    return merge(left,right);
}