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

快速排序
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