排序算法 -冒泡/选择/插入/快速/堆排序

目录

1、冒泡排序

2、选择排序

3、插入排序

4、快速排序 - 左右交换

5、堆排序

---

1、冒泡排序

var popSort = function(arr) {
    for(let i=0; i < arr.length-1; i++) {
        for(let j=0; j < arr.length-1-i; j++) {
            if (arr[j] > arr[j+1]) change(arr, j, j+1);
        }
    }

    function change(arr, a, b){
        arr[a] = arr[a]^arr[b];
        arr[b] = arr[a]^arr[b];
        arr[a] = arr[a]^arr[b];
    }
    return arr;
};

2、选择排序

var selectSort = function(arr) {
    for(let i=0; i < arr.length-1; i++) {
        let min = i;
        for(let j=i+1; j < arr.length; j++) {
            if(arr[j] < arr[min]) min = j;
        }
        if(i != min) change(arr, i, min);  //用位运算交换时，注意序号是否相等，相等时的异或结果为0
    }

    function change(arr, a, b){
        arr[a] = arr[a]^arr[b];
        arr[b] = arr[a]^arr[b];
        arr[a] = arr[a]^arr[b];
    }
    return arr.splice(0, k);
};

3、插入排序

var insertSort = function(arr) {
    const sorted = [arr[0]];
    for(let i=1; i < arr.length; i++) {
        let j = sorted.length-1;  
        while (arr[i]<sorted[j]) {
            sorted[j+1] = sorted[j];
            j--;
        }
        sorted[++j] = arr[i];
    }
    return sorted;
};


//标准
function insertionSort(arr) {
    var len = arr.length;
    var preIndex, current;
    for (var i = 1; i < len; i++) {
        preIndex = i - 1;
        current = arr[i];
        while(preIndex >= 0 && arr[preIndex] > current) {
            arr[preIndex+1] = arr[preIndex];
            preIndex--;
        }
        arr[preIndex+1] = current;
    }
    return arr;
}

4、快速排序 - 左右交换

var quickSort = function(arr, left = 0, right = arr.length-1) {
    if(left<right) {
        let mid = partition(arr, left, right);
        quick(arr, left, mid-1);
        quick(arr, mid+1, right);
    }
    return arr;
}

// 分区
function partition(arr, left, right) {
    let 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 left;   
}

5、堆排序

// 交换数组中 i和j 位置上的数
function swap(arr, i, j){
    let temp = arr[i];
    arr[i] = arr[j];
    arr[j] = temp;
}

function heapify(arr, root, end){
    for(let child = 2*root+1; child <= end; child = 2*root+1) {
        // 选出较大的子节点
        if (child+1<=end && arr[child]<arr[child+1]) child++; 
        // 较大的数放到父节点上，再检查交换后的子节点以下
        if (arr[root]<arr[child]) {
            swap(arr, root, child);
            root = child;
        } else{
            break;
        }
    }
}

function heapSort(arr) {
    const len=arr.length;
    // 初始化构建大顶堆，从第一个非叶子节点开始
    for(let i=Math.floor(len/2-1); i>=0; i--){
        heapify(arr, i, len-1);
    }
    for(let i=len-1; i>0; i--) {
        swap(arr, 0, i);   // 堆顶（最大）与 最后一个节点 交换
        heapify(arr, 0, i-1);  // 调整除去后面节点的堆
    }
    return arr;
}