JavaScript 提供了 Array.prototype.sort() 方法来对数组中的元素进行排序。默认情况下，sort() 方法使用字典序来排序字符串。如果要按照数字大小进行排序，需要传递一个比较函数。
常用排序算法：
- 冒泡排序
- 选择排序
- 插入排序
- 快速排序
- 归并排序
- 堆排序
如果需要对大数据进行排序，建议使用更高效的排序算法，比如快速排序或归并排序。
1、冒泡排序
冒泡排序是一种简单的排序算法。它重复地遍历要排序的数列，一次比较两个元素，如果它们的顺序错误就把它们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。
以下是 JavaScript 中实现冒泡排序的示例代码：
function bubbleSort(arr) {
for (let i = 0; i < arr.length; i++) {
for (let j = 0; j < arr.length - i - 1; j++) {
if (arr[j] > arr[j + 1]) {
let temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
}
return arr;
}
冒泡排序是稳定排序。时间复杂度为 O(n^2)，空间复杂度为 O(1)，因此在处理大数据集时效率较低。
2、选择排序
选择排序是一种简单的排序算法，它的基本思想是每一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，直到全部待排序的数据元素排完。
以下是 JavaScript 中实现选择排序的示例代码：
function selectionSort(arr) {
for (let i = 0; i < arr.length - 1; i++) {
let minIndex = i;
for (let j = i + 1; j < arr.length; j++) {
if (arr[j] < arr[minIndex]) {
minIndex = j;
}
}
if (minIndex !== i) {
let temp = arr[i];
arr[i] = arr[minIndex];
arr[minIndex] = temp;
}
}
return arr;
}
选择排序是不稳定排序。时间复杂度为 O(n^2)，空间复杂度为 O(1)，因此在处理大数据集时效率较低。
选择排序的优化版本有堆排序，它的时间复杂度为O(nlogn)，空间复杂度为O(1)。
3、插入排序
插入排序是一种简单的排序算法。它的基本思想是将一个数据元素插入到已经排好序的有序数据中，从而得到一个新的、个数加一的有序数据，算法适用于少量数据的排序。
以下是 JavaScript 中实现插入排序的示例代码：
function insertionSort(arr) {
for (let i = 1; i < arr.length; i++) {
let key = arr[i];
let j = i - 1;
while (j >= 0 && arr[j] > key) {
arr[j + 1] = arr[j];
j--;
}
arr[j + 1] = key;
}
return arr;
}
插入排序是稳定的排序算法。时间复杂度为 O(n^2)，空间复杂度为 O(1)。因此当待排序数据量小或部分有序时，插入排序效率较高。
4、快速排序
快速排序是一种分治算法。它的基本思想是通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。
以下是 JavaScript 中实现快速排序的示例代码：
function quickSort(arr) {
if (arr.length <= 1) {
return arr;
}
let pivotIndex = Math.floor(arr.length / 2);
let pivot = arr.splice(pivotIndex, 1)[0];
let left = [];
let right = [];
for (let i = 0; i < arr.length; i++) {
if (arr[i] < pivot) {
left.push(arr[i]);
} else {
right.push(arr[i]);
}
}
return quickSort(left).concat([pivot], quickSort(right));
}
快速排序不是稳定排序算法。时间复杂度最差为 O(n^2)，平均为O(n*log(n))，空间复杂度为 O(log(n))，是一种高效的排序算法。
快排常常被认为是排序算法中最快的，但是在最坏情况下，比如每次都选到最大值或最小值作为 pivot，就会变成 O(n^2) 的，所以在实际应用中，选取 pivot 的方法很重要。
5、归并排序
归并排序是一种分治算法。它的基本思想是将待排序的序列分成若干个长度为1的子序列，然后不断地将相邻的两个有序子序列合并，直到最后得到一个完整的有序序列。
以下是 JavaScript 中实现归并排序的示例代码：
function mergeSort(arr) {
if (arr.length <= 1) {
return arr;
}
let middle = Math.floor(arr.length / 2);
let left = arr.slice(0, middle);
let right = arr.slice(middle);
return merge(mergeSort(left), mergeSort(right));
}
function merge(left, right) {
let result = [];
while (left.length && right.length) {
if (left[0] < right[0]) {
result.push(left.shift());
} else {
result.push(right.shift());
}
}
return result.concat(left, right);
}
归并排序是稳定排序算法。时间复杂度为 O(n*log(n))，空间复杂度为 O(n)，属于高效排序算法。
归并排序是一种稳定的排序算法。时间复杂度和空间复杂度都比较高，在处理大数据集时效率较低。在实际应用中，归并排序常常与其他排序算法相结合，比如归并排序+快排，来提高算法的性能。
6、堆排序
堆排序是一种选择排序算法，它的基本思想是利用堆这种数据结构所设计的一种排序算法。堆是一种近似完全二叉树的结构，并同时满足堆积的性质：即子节点的键值或索引总是小于（或者大于）它的父节点。
以下是 JavaScript 中实现堆排序的示例代码：
function heapSort(arr) {
buildMaxHeap(arr);
for (let i = arr.length - 1; i > 0; i--) {
swap(arr, 0, i);
heapify(arr, 0, i);
}
return arr;
}
function buildMaxHeap(arr) {
let start = Math.floor(arr.length / 2) - 1;
for (let i = start; i >= 0; i--) {
heapify(arr, i, arr.length);
}
}
function heapify(arr, i, max) {
let index, leftChild, rightChild;
while (i < max) {
index = i;
leftChild = 2 * i + 1;
rightChild = 2 * i + 2;
if (leftChild < max && arr[leftChild] > arr[index]) {
index = leftChild;
}
if (rightChild < max && arr[rightChild] > arr[index]) {
index = rightChild;
}
if (index === i) {
return;
}
swap(arr, i, index);
i = index;
}
}
function swap(arr, i, j) {
let temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
堆排序是不稳定排序算法，时间复杂度为 O(n*log(n))，空间复杂度为 O(1)。因此堆排序是一种高效排序算法。
堆排序是一种不稳定的排序算法，时间复杂度比较优秀，且实现简单，属于高效排序算法。
