排序相关算法

// 冒泡排序 时间复杂度 n^2
function sort(arr) {
    for(let i = 0; i < arr.length; i++){
        for(let j = i+1; j < arr.length; j++) {
            if(arr[j] < arr[i]) { // es6可使用解构交换值
                let tmp = arr[j];// [arr[j], arr[i]] = [arr[i], arr[j]];
                arr[j] = arr[i];
                arr[i] = tmp;
            }
        }
    }
    return arr;
}

// 选择排序 时间复杂度 n^2
// 选择一个最小的，之后遇到大的就跟他换，选择最小的放到前面去
function sort(arr) {
    for(let i = 0; i < arr.length; i++){
        let min = i
        for(let j = i+1; j < arr.length; j++) {
            if(arr[j] < arr[min]) {
                min = j;
            }
        }
        [arr[i], arr[min]] = [arr[min], arr[i]];
    }
    return arr;
}

// 插入排序 时间复杂度 n^2
// 相当于摸牌 从i=1开始，两两交换下表小于1位置的值，一组交换完成j--继续比较
function sort(arr) {
    // i代表摸来的扑克牌
    for(let i = 1; i < arr.length; i++){
        let j = i - 1; // 我们手里的牌
        while(j >= 0 && arr[j] > arr[j+1]) {
            [arr[j], arr[j+1]] = [arr[j+1], arr[j]];
            j--;
        }
    }
    return arr;
}

// 希尔排序 时间复杂度 n*logn ～ n^2
// 插入排序的改进
// 保证区间内有序（gap），gap=1就是全局有序
function sort(arr) {
    function insertSort(arr, gap) {
        for(let i = gap; i < arr.length; i++){
            let j = i - gap;
            while(j >=0 && arr[j] > arr[j+gap]) {
                [arr[j], arr[j+gap]] = [arr[j+gap],arr[j]]
                j-= gap;
            } 
        }
    }
    let mid = arr.length >> 1;
    while(mid >=1) {
        insertSort(arr, mid);
        mid >>= 1;
    }
    return arr;
}

// 快速排序 时间复杂度 nlogn
// (1)首先设定一个分界值，通过该分界值将数组分成左右两部分。
// (2)将大于或等于分界值的数据集中到数组右边，小于分界值的数据集中到数组的左边。此时，左边部分中各元素都小于分界值，而右边部分中各元素都大于或等于分界值。
// (3)然后，左边和右边的数据可以独立排序。对于左侧的数组数据，又可以取一个分界值，将该部分数据分成左右两部分，同样在左边放置较小值，右边放置较大值。右侧的数组数据也可以做类似处理。
// (4)重复上述过程，可以看出，这是一个递归定义。通过递归将左侧部分排好序后，再递归排好右侧部分的顺序。当左、右两个部分各数据排序完成后，整个数组的排序也就完成了。

// 分治思想，局部排序，左半部分是有序的 右半部分是有序的 全部都有序
// partition是返回中间节点的

function sort(arr, left, right) {
    function partition(arr,left, right) {
       const temp = arr[left];
       while(left < right) {
        while(left < right && arr[right] >= temp) {
            right --
        }
        arr[left] = arr[right];
        while(left < right && arr[left] <= temp) {
            left++;
        }
        arr[right] = arr[left];
       }
       arr[left] = temp;
       return temp;
    }
    if(left < right) {
        const mid = partition(arr, left, right);
        sort(arr, left, mid-1);
        sort(arr, mid +1, right);
    }
    return arr;
}