排序

冒泡排序

所谓冒泡排序，就是从第一个元素开始，用下一个元素和当前元素做比较，如果下一个元素大于当前元素，就交换双方的位置，第一轮结束时，最后一个元素就是数组中最大的值；第二轮结束时，拿到倒数第一个最大的值，如此往返循环；

注意：因为冒泡排序每次都会拿到当前参与项中最大的一个值，所以第一层for循环，每遍历一次都会减少一次，这也是为了节约性能，对于已经排列的好的各项，不再参与遍历；

function bubbleSort(arr) {
    // 判断是否为数组
    function isArray(arr) {
        return Array.isArray(arr);
    }
    // 交换位置
    function changePosition(arr, minIndex, maxIndex) {
        let maxValue = arr[maxValue ];        
        arr[maxIndex] = arr[minIndex];
        arr[minIndex] = maxValue;
    }
    if (!isArray(arr)) {
        throw '不是一个数组';
    }
    for (let i = arr.length-1; i > 0; i-- ) {
        for (let j = 0; j < i; j++) {
             if (arr[j] > arr[j+1]) {
                 changePosition(arr, j, j+1);
             }
        }
    }
    return arr;
}

插入排序

• 第一个元素默认是已排序元素，取出下一个元素和当前元素比较，如果当前元素大，就交换位置，第一轮遍历结束；
• 进行第二轮遍历，此时，前两位元素已经做好排序，此时第二个元素作为当前元素，再拿第三个元素和当前元素做比较，如果当前元素大，就交换位置，此时第二个元素作为当前元素，当前元素和第一个元素做比较，如果第一个元素大就交换位置，如此往复；
• 讲的比较绕口，请看代码：

function insertSort(arr) {
    function isArray(arr) {
        return Array.isArray(arr);
    }
    function changePosition(arr, minIndex, maxIndex) {
        let maxValue = arr[maxIndex];
        arr[maxIndex] = arr[minIndex];
        arr[minIndex] = maxValue;
    }
    for (let i = 1; i < arr.length; i++) {
        // 注意此处：arr[j] > arr[j+1]也是为了节约性能，可以思考下；
        for (let j = i - 1; j >= 0 && arr[j] > arr[j+1]; j--) {
             changePosition(arr, j, j+1)
        }
    }
    return arr;
}

快速排序

所谓快速排序，就是在数组中找一个基点，将大于这个基点的放于右侧，小于基点的放于左侧；然后对两侧的数据进行递归调用，直到每个数组中只保留一个值，以实现快排；

function quickSort(arr) {
    function isArray(arr) {
         return Array.isArray(arr);
    }
    if (!isArray(arr)) throw '不是一个数组';
    if (arr.length <= 1) return arr;
    let pivotIndex = Math.floor(arr.length / 2);
    let pivot = arr.splice(pivotIndex, 1)[0];
    let leftArr = [];
    let rightArr = [];
    for (let i = 0; i < arr.length; i++) {
         if (arr[i] < pivot) {
              leftArr.push(arr[i]);
         } else {
              rightArr.push(arr[i]);
         }
    }
    return quickSort(leftArr).concat([pivot], quickSort(rightArr));
}

选择排序

所谓选择排序，从第一轮遍历开始设置默认最小值的索引为0，依次遍历数组，如果下一个元素比当前索引的最小值小，则设置该元素的索引为最小值的索引，一轮遍历结束后，交换第一个元素和最小值元素的位置；如上反复操作；

function selectSort(arr) {
    function isArray(arr) {
         return Array.isArray(arr);
    }
    if (!isArray(arr)) {
         throw '不是一个数组';
    }
    function changePosition(arr, minIndex, maxIndex) {
         let maxValue = arr[maxIndex];        
         arr[maxIndex] = arr[minIndex];
         arr[minIndex] = maxValue;
    }
    for (let i = 0; i < arr.length; i++) {
         let minIndex = i;
         for (let j = i + 1; j < arr.length; j++) {
              minIndex = arr[j] < arr[minIndex] ? j : minIndex;
         }
         changePosition(arr, minIndex, i);
    }
    return arr;
}

第一次写，写的不好欢迎批评指正，谢谢!