1. 冒泡排序:

\- 比较相邻的元素。如果第一个比第二个大，就交换它们两个
\- 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对，这样在最后的元素应该会是最大的数
\- 针对所有的元素重复以上的步骤，除了最后一个
\- 重复步骤1~3，直到排序完成
\- console.time()/timeEnd(),相同参数即可显示之间的时间

function sortArray(arr) {
    let tmp;
    for (let i = 0; i < arr.length-1;i++) {
        for(let j = 0 ; j < arr.length-1;j++){
            if(arr[j] > arr[j+1]){
                tmp = arr[j];
                arr[j] = arr[j+1];
                arr[j+1] = tmp;
            }
        }
    }
}

改进1：设置标志位pos，每一层排完序之后，就记录排到最大的哪一位在什么位置，因为每一层最大的数就是它所在数组的倒数的位数,下一次就没必要再循环一遍

function sortArray(arr) {
    let i = arr.length-1;
    while(i > 0) {
        var pos = 0;
        for(let j = 0 ; j < i;j++){
            if(arr[j] > arr[j+1]){
                pos = j;
                var tmp = arr[j];
                arr[j] = arr[j+1];
                arr[j+1] = tmp;
            }
        }
        i = pos;
    }
}

改进2：每趟排序从正反向冒泡一次得到两个最终值(最大和最小值)，排序次数几乎减少一半

function sortArray(arr) {
    let low = 0;
    let high = arr.length-1;
    while(low < high) {
        for (var i = low; i < high; i++) {
            if (arr[i] > arr[i+1]) {
                var tmp = arr[i];
                arr[i] = arr[i+1];
                arr[i+1] = tmp;
            }
        }
        --high;
        for(let j = high ; j > low ;j--){
            if(arr[j] < arr[j-1]){
                var tmp = arr[j];
                arr[j] = arr[j-1];
                arr[j-1] = tmp;
            }
        }
        ++low;
    }
}

2. 选择排序:

首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。

function sortArray(arr) {
    for (let i = 0; i < arr.length-1;i++) {
        let pos = i;
        for(let j = i +1; j < arr.length;j++){
            if(arr[pos] > arr[j]){
                pos = j;
            }
        }
        let tmp = arr[i];
            arr[i] = arr[pos];
            arr[pos] = tmp;
    }
}