快速排序和冒泡排序，二者效率比較

快速排序
let arr1 = [1, 23, 4, 2, 5, 6, 90, 0, 2, 55, 1.3]

function quickSort(arr) {
    if (arr.length <= 1) {
        return arr;
    }
    let pivotIndex = Math.floor(arr.length / 2),
        pivot = arr.splice(pivotIndex, 1)[0],
        left = [],
        right = [];
    for (let i = 0; i < arr.length; i++) {
        if (arr[i] < pivot) {
            left.push(arr[i])
        } else {
            right.push(arr[i])
        }
    }
    return quickSort(left).concat(pivot, quickSort(right))
}

quickSort(arr1) //[0, 1, 1.3, 2, 2, 4, 5, 23, 55, 90]
冒泡排序
function bubbleSort(arr) {
    //設置一個變量，當排序結束（即沒有元素需要交換）時，
    let exchange = false
    // 數組元素兩兩交換，每次循環需要length-1輪
    let len = arr.length - 1
    //外層循環數組元素，內層交換位置
    for (let i = 0; i < len; i++) {
        // 每輪排序中:需要比較的元素個數比上一輪少一個（每一輪的最後一個值一定是最大的）
        for (let j = 0; j < len - i; j++) {
            if (arr[j] > arr[j + 1]) {
                // 輔助交換位置的中間變量
                let temp = arr[j + 1]
                arr[j + 1] = arr[j]
                arr[j] = temp
                exchange = true
            }
        }
        if (exchange) {
            exchange = false
        } else {
            break
        }
    }
    return arr
}
二者效率比較
爲方便看出效果，編寫函數生成數組 createArr(); compare();

// 生成數組
function createArr(count){
    let arr=[];
    for(let i=0;i<count;i++){
        arr[i]=Math.floor(Math.random()*(count+1));
        arr.push(arr[i]);
    }
    return arr;
}

//計算運行時間
function compare(func,count){
    let start,stop;
    let arr=createArr(count);
    start=Date.now();
    func(arr);
    stop=Date.now();
    result=stop-start;
    console.log(result);
}

compare(bubbleSort,100);//6
compare(quickSort,100);//0
compare(bubbleSort,1000);//20
compare(quickSort,1000);//4
compare(bubbleSort,10000);//1697
compare(quickSort,10000);//12
// 單位毫秒
//具體計算時間受硬件影響
//但總體上能看出冒泡排序明顯與快速排序有很大差距