js排序算法

(1)冒泡排序
(2)选择排序
(3)插入排序
(4)希尔排序
(5)归并排序
(6)快速排序
(7)基数排序
(8)堆排序
(9)计数排序
(10)桶排序

(1)冒泡排序

时间复杂度：O(n2)
算法稳定性: 稳定
算法原理：
	1. 比较相邻的元素。如果第一个比第二个大，就交换他们两个。
	2. 对每一对相邻元素做同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素会是最大的数。
	3. 针对所有的元素重复以上的步骤，除了最后一个。
	4. 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。

// 冒泡排序
function sortBubble(arr) {
    const result = [...arr];
    for (let i = 0; i < result.length; i++) {
        let j = i + 1;
        for (; j < result.length; ) {
            if (result[i] > result[j]) {
                const temp = result[i];
                result[i] = result[j];
                result[j] = temp;
            }
            console.log('result', result);

            j++;
        }
    }
    return result;
}

const arr = [3, 2, 1, 0];
console.log('sortBubble(arr)', sortBubble(arr));

// result [ 2, 3, 1, 0 ]
// result [ 1, 3, 2, 0 ]
// result [ 0, 3, 2, 1 ]
// result [ 0, 2, 3, 1 ]
// result [ 0, 1, 3, 2 ]
// result [ 0, 1, 2, 3 ]
// sortBubble(arr) [ 0, 1, 2, 3 ]

(10)桶排序

适用范围：待排数组A[N]，元素均匀分布在某一范围[min,max]

// 链表元素，用于桶内的元素排序
function ListNode(val) {
    this.val = val;
    this.next = null;
}

// nums待排数组，内有浮点数，均匀分布在[0,10]的范围
// len：桶的个数
function bucketSort(nums, len) {
    const results = [...nums];
    if (results.length <= 1) return results;

    let bucket = [];
    for (let i = 0; i < len; i++) {
        bucket[i] = new ListNode(0);
    }

    // 桶内链表排序
    for (const num of results) {
        // 获取应该插入到哪个桶内
        let idx = getBucketIndex(num);
        let insertNode = new ListNode(num);
        if (bucket[idx].next === null) {
            // 无元素，插入元素
            bucket[idx].next = insertNode;
        } else {
            // 有元素，插入到合适的位置
            let pre = bucket[idx];
            let cur = pre.next;
            while (cur !== null && cur.val <= num) {
                pre = cur;
                cur = cur.next;
            }

            insertNode.next = cur;
            pre.next = insertNode;
        }
    }
    // bucket = [
    //     {"val": 0, "next": {"val": 0.16, "next": {"val": 0.18, "next": null}}},
    //     {"val": 0, "next": null},
    //     {"val": 0, "next": {"val": 2.12, "next": {"val": 2.18, "next": null}}},
    //     {"val": 0, "next": {"val": 3.66, "next": null}},
    //     {"val": 0, "next": {"val": 4.12, "next": null}},
    //     {"val": 0, "next": {"val": 5.1, "next": {"val": 5.28, "next": null}}},
    //     {"val": 0, "next": null},
    //     {"val": 0, "next": {"val": 7.88, "next": {"val": 7.99, "next": null}}},
    //     {"val": 0, "next": {"val": 8.12, "next": null}},
    //     {"val": 0, "next": {"val": 9.66, "next": null}},
    //     {"val": 0, "next": null},
    //     {"val": 0, "next": null}
    // ]

    // 桶内元素输出
    let index = 0;
    for (let i = 0; i < len; i++) {
        let node = bucket[i].next;
        if (node === null) continue;
        while (node !== null) {
            results[index] = node.val;
            index++;
            node = node.next;
        }
    }
    return results;
}

// 计算放入哪个桶中
// 当前例子是，浮点数转化为整数，作为桶的索引值，实际开发要根据场景具体设计
function getBucketIndex(num) {
    return parseInt(num);
}

const arr = [
    2.18,
    0.18,
    0.16,
    2.12,
    3.66,
    7.88,
    7.99,
    8.12,
    9.66,
    5.1,
    4.12,
    5.28
];

console.log(bucketSort(arr, arr.length));
// [0.16, 0.18, 2.12, 2.18, 3.66, 4.12, 5.1, 5.28, 7.88, 7.99, 8.12, 9.66];

// https://blog.csdn.net/Zsk_Zane/article/details/100128612