本文共 2876 字，大约阅读时间需要 9 分钟。

5种JavaScript中常用的排序方法

01、冒泡排序

冒泡排序通过相邻数据元素的交换，逐步将待排序序列变为有序序列。如果前面的数据大于后面的数据，就将两值进行交换，将数据从小到大的排序。这种方法的时间复杂度为O(n²)，通常用于数据规模较小的排序。

function maopao(array) {
    if (Array.isArray(array)) {
        if (array.length === 1) {
            return array;
        }
        var temp = null;
        for (var i = 0; i < array.length; i++) {
            for (var j = 0; j < array.length - i - 1; j++) {
                if (array[j] > array[j + 1]) {
                    [array[j], array[j + 1]] = [array[j + 1], array[j]];
                }
            }
        }
        return array;
    }
}
console.log(maopao([1, 5, 7, 6, 0, 9, 4])); // 输出：0，1，4，5，6，7，9

02、选择排序

选择排序通过每次在未排序的数据中找到最小的元素，将其移到已排序区的末尾，直到所有元素都排好序。这种方法的时间复杂度为O(n²)，适用于各种数据规模，但效率不如快排。

function xuanze(array) {
    if (Array.isArray(array)) {
        if (array.length === 1) {
            return array;
        }
        for (var i = 0; i < array.length - 1; i++) {
            var minIndex = i;
            for (var j = i + 1; j < array.length; j++) {
                minIndex = array[minIndex] < array[j] ? j : minIndex;
            }
            [array[i], array[minIndex]] = [array[minIndex], array[i]];
        }
        return array;
    }
}
console.log(xuanze([1, 4, 2, 0, 3, 8, 6])); // 输出：8，6，4，3，2，1，0

03、递归排序（快排）

递归排序每次选择一个基准元素，将数组分为左右两部分，左边小于等于基准，右边大于基准，然后递归对左右两部分分别排序。这种方法的平均时间复杂度为O(n log n)，适用于较大的数据量。

function digui(array) {
    if (Array.isArray(array)) {
        if (array.length <= 1) {
            return array;
        }
        var centerIndex = Math.ceil(array.length / 2);
        var cValue = array.splice(centerIndex, 1);
        var left = [];
        var right = [];
        array.forEach(function (value) {
            if (value > cValue) {
                left.push(value);
            } else {
                right.push(value);
            }
        });
        return digui(left).concat(cValue, digui(right));
    }
}
console.log(digui([1, 9, 4, 2, 5, 3, 8, 6, 7, 0])); // 输出：9，8，7，6，5，4，3，2，1，0

04、插入排序

插入排序将要排序的数组分成两部分，每次从后面的部分取出索引最小的值插入前面适当的位置。这种方法的时间复杂度为O(n²)，适用于多次稳定排序。

function charu(array) {
    if (Array.isArray(array)) {
        if (array.length === 1) {
            return array;
        }
        for (var i = 1; i < array.length; i++) {
            var current = array[i];
            var preIndex = i - 1;
            while (preIndex >= 0 && array[preIndex] < current) {
                array[preIndex + 1] = array[preIndex];
            }
            array[preIndex + 1] = current;
        }
        return array;
    }
}
console.log(charu([1, 9, 4, 2, 5, 3, 0, 8, 6, 7])); // 输出：9，8，7，6，5，4，3，2，1，0

05、sort()函数

JavaScript的内置sort()函数采用快速排序的实现，默认为升序排列，可通过比较函数实现定制排序。这种方法在性能上表现优异，通常用于处理大数据量。

var arr5 = [1, 9, 4, 2, 5, 3, 0, 8, 6, 7];
arr5.sort();
console.log(arr5); // 输出：0，1，2，3，4，5，6，7，8，9

总结

通过接触与学习这五种排序方法，我对JavaScript中的排序实现有了更深入的理解。选用的方法各有优劣，适合不同场景。通过不断练习和自我验证，我的排序算法能力也有所提升。