js实现排序算法

一、交换排序

交换函数

function swapNum(arr, i, j) {
    let temp = arr[i];
    arr[i] = arr[j];
    arr[j] = temp;
}

1.冒泡排序

平均时间复杂度O(n^2),空间复杂度O(1), 稳定

function bubbleSort2(arr) {
    do {
        var flag = false;
        for (let i = 0; i < arr.length; i++) {
            if (arr[i] > arr[i + 1]) {
                swapNum(arr, i, i + 1);
                flag = true;
            }
        }
    } while (flag);
    return arr;
}

2. 快速排序

平均时间复杂度O(nlogn),空间复杂度O(logn),不稳定

function quickSort(arr, left, right) {
    if (left < right) {
        let i = left,
            j = right,
            temp = arr[left];
        while (i < j) {
            while (i < j && temp <= arr[j]) {
                j--;
            }
            if (i < j) {
                arr[i++] = arr[j];
            }
            while (i < j && temp > arr[i]) {
                i++;
            }
            if (i < j) {
                arr[j--] = arr[i];
            }
        }
        arr[i] = temp;
        quickSort(arr, left, i - 1);
        quickSort(arr, i + 1, right);
    }
    return arr;
}

二、插入排序

1. 简单插入排序

平均时间复杂度O(n^2),空间复杂度O(1),稳定

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

2. 希尔排序

平均时间复杂度O(nlogn),空间复杂度O(1), 不稳定

function shellSort(arr) {
    for (let gap = Math.floor(arr.length / 2); gap > 0; gap = Math.floor(gap / 2)) {
        for (let i = gap; i < arr.length; i++) {
            let j = i;
            while (j > 0 && arr[j - gap] > arr[j]) {
                swapNum(arr, j, j - gap);
                j = j - gap;
            }
        }
    }
    return arr;
}

三、选择排序

1. 简单选择排序

平均时间复杂度O(n^2),空间复杂度O(1),不稳定

function mySort(arr) {
    var len = arr.length;
    for (let i = 0; i < len; i++) {
        let min = i;
        for (let j = i + 1; j < len; j++) {
            if (arr[min] > arr[j]) {
                swapNum(arr, j, min);
            }
        }
    }
    return arr;
}

2. 堆排序

平均时间复杂度O(nlogn),空间复杂度O(1),不稳定

function buildHeap(items, heapSize) {
    for (let i = Math.floor(heapSize / 2); i >= 1; i--) {
        heapify(items, heapSize, i);
    }
}

function heapify(items, heapify, i) {
    while (true) {
        let minIndex = i;
        if (2 * i <= heapify && items[2 * i] < items[minIndex]) {
            minIndex = 2 * i;
        }
        if (2 * i + 1 <= heapify && items[2 * i + 1] < items[minIndex]) {
            minIndex = 2 * i + 1;
        }
        if (minIndex !== i) {
            swapNum(items, i, minIndex);
            i = minIndex;
        } else {
            break;
        }
    }
}

四、归并排序

平均时间复杂度O(nlogn),空间复杂度O(n),稳定

function mergeSort(arr) {
    if (arr.length < 2) {
        return arr;
    }
    const middle = Math.floor(arr.length / 2);
    const left = arr.slice(0, middle);
    const right = arr.slice(middle);
    return merge(mergeSort(left), mergeSort(right));
}

function merge(left, right) {
    const result = [];
    while (left.length && right.length) {
        if (left[0] > right[0]) {
            result.push(right.shift());
        } else {
            result.push(left.shift());
        }
    }
    return result.concat(left, right);
}

五、桶排序

function bucketSort(arr, bucketsize) {
    let length = arr.length;
    if (length === 0 || length === 1) {
        return arr;
    }
    //求解arr的最大值 最小值，用来计算桶数量
    let i = 0,
        min = arr[0],
        max = arr[0];
    for (let i = 0; i < length; i++) {
        if (min > arr[i]) {
            min = arr[i];
        }
        if (max < arr[i]) {
            max = arr[i];
        }
    }
    const defaultBucketSize = 5;
    bucketsize = bucketsize || defaultBucketSize;
    const bucketCount = Math.floor((max - min) / bucketsize) + 1;
    let bucket = new Array(bucketCount);
    for (let i = 0; i < bucketCount; i++) {
        bucket[i] = [];
    }
    for (let i = 0; i < length; i++) {
        bucket[Math.floor((arr[i] - min) / bucketsize)].push(arr[i]);
    }
    arr.length = 0;
    for (let i = 0; i < bucketCount; i++) {
        insertSort(bucket[i]);
        for (let item of bucket[i]) {
            arr.push(item);
        }
    }
    return arr;
}

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