js常見排序算法實現

1.冒泡排序

原理：對數組進行遍歷，根據相鄰兩個元素大小進行交換，每一次遍歷都將最小值推至最前方，而後對剩下的值再次進行比較

空間複雜度：O(1)

時間複雜度：O(n^2)

穩定性：穩定

// 冒泡排序
function bubbleSort(arr) {
    let len = arr.length - 1, tmp
    for (let i = 0; i < len; i++) {
        for (let j = 0; j < len - i; j++) {
            if (arr[j] > arr[j + 1]) {
                tmp = arr[j]
                arr[j] = arr[j + 1]
                arr[j + 1] = tmp
            }
        }
    }
    return arr
}

2.快速排序

原理：從數組中取一個基準值，將剩下的值與基準值比較，小於的放到左邊，大於的放到右邊，並對左右兩邊進行快速排序，重複直到左右兩邊只剩一個元素，最後合併

平均時間複雜度O(nlogn)

最壞時間複雜度：O(n^2)

穩定性：不穩定

// 快速排序
function quickSort(arr) {
    let len = arr.length
    if (len < 2) {
        return arr;
    }
    let index = Math.floor(len / 2);
    let pindex = arr.splice(index, 1)[0]; // 去除基準值
    let left = [], right = [];
    arr.forEach(item => {
        if (item > pindex) {
            right.push(item);
        } else {
            left.push(item);
        }
    })
    return quickSort(left).concat([pindex], quickSort(right))
}

 3.插入排序

原理：將數組分紅兩個，一個是已排序，一個是待排序，將待排序中的元素與已排序的元素進行比較並插入到適當位置

最好時間複雜度：O(n)，當數組已經由小到大排序好

最壞時間複雜度：O(n^2)，當數組是由大到小排序，與冒泡排序相同

空間複雜度：O(1)

穩定性：穩定

// 插入排序
function insertSort(arr) {
    let len = arr.length;
    let prev, cur;
    for (let i = 1; i < len; i++) {
        prev = i - 1;
        cur = arr[i];
        while(prev >= 0 && arr[prev] > cur) {
            arr[prev + 1] = arr[prev];
            prev--;
        }
        arr[prev + 1] = cur;
    }
    return arr;
}

4.希爾排序

原理：將整個數組經過設置步長分爲一個個分塊，對每一個分塊進行序列化，最後進行一次插入排序

時間複雜度：O(nlogn)~O(n²)，通常爲O(n^1.5)，數組有序程度越高，排序越快

空間複雜度：O(1)

穩定性：穩定

// 希爾排序
function shellSort(arr) {
    let len = arr.length;
    let tmp;
    let gap = Math.floor(len / 2);
    while(gap > 0) {
        for (let i = gap; i <len; i++) {
            for (let j = i; j >= gap && arr[j] < arr[j - gap]; j -= gap) {
                tmp = arr[j];
                arr[j] = arr[j - gap];
                arr[j - gap] = tmp;
            }
        }
        gap = Math.floor(gap / 2);
    }
    return arr;
}

5.選擇排序

原理：從數組第一個元素開始，與後面全部元素進行比較，若是有比其小的值，則交換二者位置

時間複雜度：O(n^2)

空間複雜度：O(1)

穩定性：穩定

// 選擇排序
function selectSort(arr) {
    let len = arr.length;
    let index, tmp;
    for (let i = 0; i < len; i++) {
        index = i;
        for (let j = i + 1; j < len; j++) {
            if (arr[index] > arr[j]) {
                index = j;
            }
        }
        tmp = arr[index];
        arr[index] = arr[i]
        arr[i] = tmp
    }
    return arr
}