JavaScript，简称JS，是Web开发中的重要脚本语言，尤其在客户端编程中不可或缺。本文将深入探讨JavaScript中几个常见的排序算法，帮助你更好地理解和运用它们。
1. 冒泡排序（Bubble Sort）
冒泡排序是一种简单的排序算法，通过比较相邻元素并交换位置，重复这个过程直到数组有序。它的基本思想是每一轮排序都将最大（或最小）的元素“冒”到数组的一端。在JavaScript中，可以这样实现：
```javascript
function bubbleSort(arr) {
var len = arr.length;
for (var i = 0; i < len - 1; i++) {
for (var j = 0; j < len - 1 - i; j++) {
if (arr[j] > arr[j + 1]) {
[arr[j], arr[j + 1]] = [arr[j + 1], arr[j]];
}
}
}
return arr;
}
```
2. 选择排序（Selection Sort）
选择排序的工作原理是每一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，直到全部待排序的数据元素排完。JavaScript中的实现如下：
```javascript
function selectionSort(arr) {
var len = arr.length;
for (var i = 0; i < len - 1; i++) {
var minIndex = i;
for (var j = i + 1; j < len; j++) {
if (arr[j] < arr[minIndex]) {
minIndex = j;
}
}
if (minIndex !== i) {
[arr[i], arr[minIndex]] = [arr[minIndex], arr[i]];
}
}
return arr;
}
```
3. 插入排序（Insertion Sort）
插入排序是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。JavaScript中的插入排序代码如下：
```javascript
function insertionSort(arr) {
var len = arr.length;
for (var i = 1; i < len; i++) {
var key = arr[i];
var j = i - 1;
while (j >= 0 && arr[j] > key) {
arr[j + 1] = arr[j];
j--;
}
arr[j + 1] = key;
}
return arr;
}
```
4. 快速排序（Quick Sort）
快速排序是一种高效的排序算法，采用分治策略。选取一个基准值，将数组分为小于基准值和大于基准值的两部分，然后对这两部分递归进行快速排序。JavaScript实现如下：
```javascript
function quickSort(arr, left = 0, right = arr.length - 1) {
if (left < right) {
var pivotIndex = partition(arr, left, right);
quickSort(arr, left, pivotIndex - 1);
quickSort(arr, pivotIndex + 1, right);
}
return arr;
function partition(arr, left, right) {
var pivot = arr[right];
var i = left - 1;
for (var j = left; j < right; j++) {
if (arr[j] < pivot) {
i++;
[arr[i], arr[j]] = [arr[j], arr[i]];
}
}
[arr[i + 1], arr[right]] = [arr[right], arr[i + 1]];
return i + 1;
}
}
```
5. 归并排序（Merge Sort）
归并排序也是一种分治算法，将大问题分解为小问题解决，然后合并结果。它将数组分为两半，分别排序，再合并。JavaScript实现如下：
```javascript
function mergeSort(arr) {
if (arr.length < 2) return arr;
var mid = Math.floor(arr.length / 2);
var left = arr.slice(0, mid);
var right = arr.slice(mid);
return merge(mergeSort(left), mergeSort(right));
function merge(left, right) {
var result = [];
while (left.length && right.length) {
if (left[0] <= right[0]) {
result.push(left.shift());
} else {
result.push(right.shift());
}
}
while (left.length) result.push(left.shift());
while (right.length) result.push(right.shift());
return result;
}
}
```
6. 堆排序（Heap Sort）
堆排序利用了堆这种数据结构。首先构造一个大顶堆（或小顶堆），然后每次将堆顶元素与最后一个元素交换，然后重新调整堆。JavaScript实现如下：
```javascript
function heapSort(arr) {
buildHeap(arr);
for (var i = arr.length - 1; i > 0; i--) {
[arr[0], arr[i]] = [arr[i], arr[0]];
siftDown(arr, 0, i);
}
return arr;
function buildHeap(arr) {
var lastParent = Math.floor((arr.length - 1) / 2);
for (var i = lastParent; i >= 0; i--) {
siftDown(arr, i, arr.length - 1);
}
}
function siftDown(arr, start, end) {
var root = start;
while (2 * root + 1 <= end) {
var child = 2 * root + 1;
if (child + 1 <= end && arr[child] < arr[child + 1]) {
child++;
}
if (arr[root] >= arr[child]) break;
[arr[root], arr[child]] = [arr[child], arr[root]];
root = child;
}
}
}
```
以上就是JavaScript中常见的几种排序算法的实现，每种算法都有其特点和适用场景。实际开发中，应根据数据规模、性能需求和稳定性等因素选择合适的排序方法。在学习这些算法时，理解其工作原理和步骤是非常重要的，这将有助于你更好地优化代码并提高程序性能。
JSRun_T42Kp.zip （2个子文件） 
main.js 3KB
README.txt 491B
