冒泡排序：双层循环，内部循环每次选出最大值或者最小值，放到头上或者放在尾部

function sort (arr, sorting = 1) {
     if (sorting < 0) { //逆序
        for (let i = 0; i < arr.length; i++) {
            for (let j = i + 1; j < arr.length; j++) {
                if (arr[i] < arr[j]) {
                    let a = arr[i];
                    arr[i] = arr[j];
                    arr[j] = a;
                }
            }
        }
     } else { //正序
        for (let i = 0; i < arr.length; i++) {
            for (let j = i + 1; j < arr.length; j++) {
                if (arr[i] > arr[j]) {
                    let a = arr[i];
                    arr[i] = arr[j];
                    arr[j] = a;
                }
            }
        }
     }
 }

快速排序：递归调用，每次递归选出一个“中值”，头部和尾部分别跟“中值”比较，找出可交换值后交换位置。每次交换后，数组的逆序减少比其他排序算法要多，所以相对比较快

function quickSort(arr, start, end, sorting = 1) {

    if(start > end){
        return;
    }
    let i = start;
    let j = end;
    let m = arr[start];
    if (sorting < 0) { //逆序
        while (i < j) {
            //先看右边，依次往左递减
            while (m <= arr[j] && i < j) {  //6<5  9
                j--;
            }
            //再看左边，依次往右递增
            while (m >= arr[i] && i < j) {  //6>=7
                i++;
            }
            //如果满足条件则交换
            if (i < j) {
                let t = arr[j];
                arr[j] = arr[i];
                arr[i] = t;
            }
        }
    } else { // 正序
        while (i < j) {
            //先看右边，依次往左递减
            while (m >= arr[j] && i < j) {  //6<5  9
                j--;
            }
            //再看左边，依次往右递增
            while (m <= arr[i] && i < j) {  //6>=7
                i++;
            }
            //如果满足条件则交换
            if (i < j) {
                let t = arr[j];
                arr[j] = arr[i];
                arr[i] = t;
            }
        }
    }
    //最后将基准为与i和j相等位置的数字交换
    arr[start] = arr[i];
    arr[i] = m;
    //递归调用左半数组
    quickSort(arr, start, j - 1, sorting);
    //递归调用右半数组
   quickSort(arr, j + 1, end, sorting);
}