JS中的算法与数据结构之常见排序(Sort)算法详解
本文将介绍JS中的算法与数据结构之常见排序(Sort)算法详解,包括排序算法的分类、原理、时间复杂度、代码实现和示例说明等。
1. 排序算法的分类
排序算法可以分为以下几类:
- 冒泡排序(Bubble Sort)
- 选择排序(Selection Sort)
- 插入排序(Insertion Sort)
- 希尔排序(Shell Sort)
- 归并排序(Merge Sort)
- 快速排序(Quick Sort)
- 堆排序(Heap Sort)
- 计数排序(Counting Sort)
- 桶排序(Bucket Sort)
- 基数排序(Radix Sort)
2. 排序算法的原理和时间复杂度
以下是常见排序算法的原理和时间复杂度:
排序算法 | 原理 | 时间复杂度 |
---|---|---|
冒泡排序 | 依次比较相邻的两个元素,将较大的元素交换到后面 | O(n^2) |
选择排序 | 从未排序的元素中选择最小的元素,放到已排序的末尾 | O(n^2) |
插入排序 | 将未排序的元素插入到已排序的合适位置 | O(n^2) |
希尔排序 | 将数组分成若干个子序列,对每个子序列进行插入排序,最后对整个数组进行插入排序 | O(nlogn) |
归并排序 | 将数组分成两个子数组,对每个子数组进行排序,然后将两个子数组合并成一个有序数组 | O(nlogn) |
快速排序 | 选择一个基准元素,将数组分成两个子数组,小于基准元素的放在左边,大于基准元素的放在右边,然后对左右两个子数组进行递归排序 | O(nlogn) |
堆排序 | 将数组构建成一个最大堆,然后将堆顶元素与最后一个元素交换,再将剩余元素重新构建成最大堆,重复此过程直到整个数组有序 | O(nlogn) |
计数排序 | 统计小于等于每个元素的个数,然后根据统计结果将元素放到正确的位置 | O(n+k) |
桶排序 | 将元素分到不同的桶中,对每个桶中的元素进行排序,然后将所有桶中的元素合并成一个有序数组 | O(n) |
基数排序 | 将元素按照位数切割成不同的数字,然后按照每个位数分别进行排序,最后合并成一个有序数组 | O(nk) |
3. 排序算法的代码实现
以下是常见排序算法的代码实现:
3.1 冒泡排序
function bubbleSort(arr) {
for (let i = 0; i < arr.length - 1; i++) {
for (let j = 0; j < arr.length - i - 1; j++) {
if (arr[j] > arr[j + 1]) {
[arr[j], arr[j + 1]] = [arr[j + 1], arr[j]];
}
}
}
return arr;
}
3.2 选择排序
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;
}
}
[arr[i], arr[minIndex]] = [arr[minIndex], arr[i]];
}
return arr;
}
3.3 插入排序
function insertionSort(arr) {
for (let i = 1; i < arr.length; i++) {
let j = i - 1;
let temp = arr[i];
while (j >= 0 && arr[j] > temp) {
arr[j + 1] = arr[j];
j--;
}
arr[j + 1] = temp;
}
return arr;
}
3.4 希尔排序
function shellSort(arr) {
let len = arr.length;
for (let gap = Math.floor(len / 2); gap > 0; gap = Math.floor(gap / 2)) {
for (let i = gap; i < len; i++) {
let j = i;
let temp = arr[i];
while (j - gap >= 0 && arr[j - gap] > temp) {
arr[j] = arr[j - gap];
j -= gap;
}
arr[j] = temp;
}
}
return arr;
}
3.5 归并排序
function mergeSort(arr) {
if (arr.length < 2) {
return arr;
}
let mid = Math.floor(arr.length / 2);
let left = arr.slice(0, mid);
let right = arr.slice(mid);
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());
}
}
while (left.length) {
result.push(left.shift());
}
while (right.length) {
result.push(right.shift());
}
return result;
}
3.6 快速排序
function quickSort(arr) {
if (arr.length < 2) {
return arr;
}
let pivot = arr[0];
let left = [];
let right = [];
for (let i = 1; i < arr.length; i++) {
if (arr[i] < pivot) {
left.push(arr[i]);
} else {
right.push(arr[i]);
}
}
return quickSort(left).concat(pivot, quickSort(right));
}
3.7 堆排序
function heapSort(arr) {
let len = arr.length;
for (let i = Math.floor(len / 2) - 1; i >= 0; i--) {
heapify(arr, len, i);
}
for (let i = len - 1; i > 0; i--) {
[arr[0], arr[i]] = [arr[i], arr[0]];
heapify(arr, i, 0);
}
return arr;
}
function heapify(arr, len, i) {
let largest = i;
let left = 2 * i + 1;
let right = 2 * i + 2;
if (left < len && arr[left] > arr[largest]) {
largest = left;
}
if (right < len && arr[right] > arr[largest]) {
largest = right;
}
if (largest !== i) {
[arr[i], arr[largest]] = [arr[largest], arr[i]];
heapify(arr, len, largest);
}
}
4. 示例
以下是两个示例说明,展示排序算法的应用场景:
4.1 示例1:冒泡排序
小明有一个数组[3, 1, 4, 2, 5],他想将数组按照从小到大的顺序排序。他使用冒泡排序算法,将数组排序后得到[1, 2, 3, 4, 5]。
4.2 示例2:快速排序
小红有一个数组[5, 3, 7, 2, 8, 4, 1, 6],她想将数组按照从小到大的顺序排序。她使用快速排序算法,将数组排序后得到[1, 2, 3, 4, 5, 6, 7, 8]。
5. 结论
通过以上介绍和示例说明,可以看JS中的算法与数据结构之常见排序(Sort)算法详解。在选择排序算法时,需要根据数据规模和时间复杂度来选择,以满足自己的需求。
本站文章如无特殊说明,均为本站原创,如若转载,请注明出处:JS中的算法与数据结构之常见排序(Sort)算法详解 - Python技术站