快速排序和冒泡排序（附二者效率比较）

快速排序
let arr1 = [1, 23, 4, 2, 5, 6, 90, 0, 2, 55, 1.3]
 
function quickSort(arr) {
 
    function sort(arr, left, right) {
        let index;
        if (arr.length > 1) {
            index = partition(arr, left, right);
            if (left < index - 1) {
                sort(arr, left, index-1);
            }
            if (right > index) {
                sort(arr, index, right);
            }
        }
    }
 
    function partition(arr, left, right) {
        let pivot = arr[Math.floor((left + right) / 2)];
        let i = left;
        let j = right;
 
        while (i <= j) {
            while (arr[i] < pivot) {
                i++;
            }
            while (arr[j] > pivot) {
                j--;
            }
            if (i <= j) {
                swap(arr, i, j);
                i++;
                j--;
            }
        }
        return i;
    }
 
    function swap(arr, index1, index2) {
        let temp = arr[index1];
        arr[index1] = arr[index2];
        arr[index2] = temp;
    }
 
    sort(arr, 0, arr.length - 1);
    return arr;
}
 
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
// 单位毫秒
//具体计算时间受硬件影响
//但总体上能看出冒泡排序明显与快速排序有很大差距

转载自：https://blog.csdn.net/weixin_41702247/article/details/84636556