JavaScript 排序算法

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)。因此堆排序是一种高效排序算法。

堆排序是一种不稳定的排序算法,时间复杂度比较优秀,且实现简单,属于高效排序算法。

 

posted @   飞仔FeiZai  阅读(82)  评论(0编辑  收藏  举报
相关博文:
阅读排行:
· 百万级群聊的设计实践
· 永远不要相信用户的输入:从 SQL 注入攻防看输入验证的重要性
· 全网最简单!3分钟用满血DeepSeek R1开发一款AI智能客服,零代码轻松接入微信、公众号、小程
· .NET 10 首个预览版发布,跨平台开发与性能全面提升
· 《HelloGitHub》第 107 期
点击右上角即可分享
微信分享提示