学习5种排序算法：

1：快速排序
2：归并排序
3：堆排序
4：冒泡排序
5：选择排序

总结

算法	时间复杂度	空间复杂度	稳定	步骤	应用	原地
快速排序	O(nlogn)/最坏 O(n2)	开辟新数组法O(n)/原地 O(logn)	不稳定	分治法，选取基数，将数组分成两部分，递归进行此操作		in-place/out-place
归并排序	O(nlogn)	O(n)	稳定	分治法，先将数组分割，然后排序，进而集成在一起	速度仅次于快速排序，一般用于总体无序，但是各子项相对有序的数列	out-place
选择排序	O(n2)	O(1)	不稳定	每次遍历找到最小值，放入左侧，依次对未排序的部分重复此操作	不占用额外空间，对空间复杂度要求较高，并且数据规模不大时候可以使用	in-place
冒泡排序	O(n2)	O(1)	稳定	比较相邻元素，如果第一个比第二个大，就交换位置，一直到最后，第二遍重复此操作(除了最后一个)	对空间复杂度要求较高，并且数据规模不大时候，需要稳定排序可以使用	in-place
堆排序	建堆O（n)，总体O(nlog n)	O(1)	不稳定	接住数据结构堆，堆是一个近似完全二叉树的结构，堆具有子节点均比父节点大/小的性质,1:建立大顶堆。2：拿出堆顶元素，将堆末尾元素拿到堆顶3：调整堆，4：重复2，3步	时间复杂度同快速排序、归并排序，特长是使用很少空间，适合相对有序的序列排序	in-place

上面 table 居然还需要滚动。。。给个图吧，方便点

1.归并排序

// 排序 并 合并
function merge (leftArr, rightArr) {
    let result = [];
    while (leftArr.length > 0 && rightArr.length > 0) {
        if(leftArr[0]<=rightArr[0]){
            result.push(leftArr.shift());
        } else {
            result.push(rightArr.shift());
        }
    }
    if(leftArr[0] || rightArr[0]) {
        result.push(leftArr[0] || rightArr[0]);
    }
    return result;
}
// 分割
function mergeSort(arr) {
    // 边界判断
    if (arr.length < 2) {
        return arr;
    }
    // 进行分割，将数组从中间分割成两部分
    const middleIndex = Math.floor(arr.length / 2);
    let left = arr.slice(0, middleIndex);
    let right = arr.slice(middleIndex);
    return merge(mergeSort(left), mergeSort(right));
}

mergeSort([32,12,56,78,76,45,36]);

2.选择排序

// 选择排序
function selectSort(arr){
    for(let j=0; j<arr.length; j++){
        let max = arr[j];
        let maxIndex = j;
        for (let i = j; i < arr.length; i++) {
            if (arr[i] > max) {
                max = arr[i];
                maxIndex = i;
            }
        }
        const temp = arr[j];
        arr[j] = arr[maxIndex];
        arr[maxIndex] = temp;
    }
    return arr;
}
selectSort([32,12,56,78,76,45,36, 45]);

3.冒泡排序

function bubbleSort(arr) {
    for (let i = arr.length - 1; i >= 0; i--) {
        for (let j = 0; j < i + 1; j++) {
            if (arr[j] > arr[j + 1]) {
                let temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
    }
    return arr;
}
bubbleSort([32,12,56,78,76,45,36, 45]);

4.快速排序

in-place

要点：最后一个元素作为 pivot，需要记下分割的 storeIndex，并初始化为-1

// 快速排序  in-place法
function quickSortInPlace(arr, left=0, right= arr.length-1){
    if(left < right){
        let storeIndex = left - 1
        for(let i=left; i<=right; i++){
            // 最后一个元素作为 pivot
            if(arr[i]<=  arr[right]){
                storeIndex++
                let temp = arr[storeIndex]
                arr[storeIndex] = arr[i]
                arr[i] = temp
            }
        }
        quickSortInPlace(arr, left, storeIndex-1)
        quickSortInPlace(arr, storeIndex+1, right)
    }
    return arr
}
let test = [5,6,9,1,4,9,67,4,0];
quickSortInPlace(test)

开辟新数组法

// 快速排序  开辟新数组法
function quickSort(arr) {
    if (arr.length < 2) {
        return arr;
    }
    const pivotIndex = Math.floor(arr.length / 2);
    const pivot = arr.splice(pivotIndex, 1)[0];
    let left = [];
    let right = [];
    arr.forEach(item => {
        if (item < pivot) {
            left.push(item);
        } else {
            right.push(item);
        }
    });
    return quickSort(left).concat(pivot, quickSort(right));
}
let test = [5,6,9,1,4,9,67,4,0];
quickSort(test)

堆排序

利用堆这种数据结构来实现的一种排序算法；堆是一种近似完全二叉树的数据结构，并且具有子节点均大于(或者小于)父节点的性质

堆排序的步骤

1.建立大顶堆
2.堆顶元素放直最后，堆未元素放置堆顶
3.调整堆
4.重复2.3步骤

function heapSort(arr) {
  function sort() {
        // 构建大顶堆
        for (let i = Math.floor(arr.length / 2) - 1; i >= 0; i--) {
            heapify(i, arr.length - 1);
        }
        // 将堆顶元素放直最后，然后重新调整堆
        for (let j = arr.length - 1; j >= 0; j--) {
            // 将堆顶元素放直最后
            swap(0, j);
            // 调整堆，从第一个，调整到最后的 j
            heapify(0, j);
        }
        return arr;
    }
    function swap(i, j) {
        let tmp = arr[i];
        arr[i] = arr[j];
        arr[j] = tmp;
    }
    function heapify(start, end) {
        let dad = start;
        let leftSon = dad * 2 + 1;
        let rightSon = dad * 2 + 2;
        // 记录最大孩子的 index
        let maxSon = leftSon;
        // 没有子节点，无需调整
        if (leftSon >= end) {
            return;
        }
        // 找到最大孩子
        if (rightSon < end && arr[maxSon] < arr[rightSon]) {
            maxSon = rightSon;
        }
        // 最大孩子与 dad 比大小
        if (arr[maxSon] > arr[dad]) { // 如果孩子大，需要换位置
            swap(maxSon, dad);
            heapify(maxSon, end);
        }
    }
    sort();
}

let a = [3, 5, 3, 0, 8, 6, 1, 5, 8, 6, 2, 4, 9, 4, 7, 0, 1, 8, 9, 7, 3, 1, 2, 5, 9, 7, 4, 0, 2, 6];
heapSort(a);