js 冒泡/快排/选择/插入 排序

冒泡排序

let arr=[1,2,234,34,34,65,76,78,5,7,99]
let len=arr.length
for(let i=0;i<len;i++){
    for(let j=i+1;j<len;j++){
        if(arr[j]<arr[i]){
            [arr[i],arr[j]]=[arr[j],arr[i]]
        }
    }
}
console.log(...arr)

快速排序

function quick(arr) {
    // 递归终止条件：当数组长度小于等于 1 时，直接返回数组
    if (arr.length <= 1) {
        return arr;
    }
    // 选择基准元素，这里选择数组中间位置的元素
    const pivotIndex = Math.floor(arr.length / 2);
    const pivot = arr[pivotIndex];
    const left = [];
    const right = [];

    // 遍历数组，将元素根据与基准元素的大小关系分别放入 left 和 right 数组
    for (let i = 0; i < arr.length; i++) {
        // 跳过基准元素，避免重复处理
        if (i === pivotIndex) {
            continue;
        }
        if (arr[i] <= pivot) {
            left.push(arr[i]);
        } else {
            right.push(arr[i]);
        }
    }

    // 递归调用 quick 函数对 left 和 right 数组进行排序，并合并结果
    return [...quick(left), pivot, ...quick(right)];
}

const arr = [3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5];
const sortedArr = quick(arr);
console.log(sortedArr);

选择排序 每次都找到一个最小值，记录最小值的索引，然后进行交换

let arr2=[1,2,234,34,34,65,76,78,5,7,99]
let len2=arr2.length
let minIndex = 0;
for(let i=0;i<len2;i++){
    minIndex = i;
    for(let j=i+1;j<len2;j++){
        if(arr2[j]<arr2[minIndex]){
            minIndex = j;
        }
    }
    [arr2[i],arr2[minIndex]]=[arr2[minIndex],arr2[i]]
}
console.log(...arr2)

插入排序 从后往前找到要插入的位置 ，元素后移，空出一个位置放入当前元素

let arr3=[1,2,234,34,34,65,76,78,5,7,99]
let len3=arr3.length
for(let i=1;i<len3;i++){
    let cur=arr3[i]
    let j=i-1
    while(j>=0&&arr3[j]>cur){
        arr3[j+1]=arr3[j]
        j--
    }
    arr3[j+1]=cur
}
console.log(...arr3)