js实现各种经典排序算法

在 JavaScript 中,可以实现多种经典的排序算法,包括冒泡排序、选择排序、插入排序、归并排序、快速排序等。以下是这些排序算法的实现代码和解释:

1. 冒泡排序(Bubble Sort)

冒泡排序是一种简单的排序算法,通过重复地遍历要排序的列表,比较相邻的元素并交换它们的位置来排序。

javascript 复制代码
function bubbleSort(arr) {
  const n = arr.length;
  for (let i = 0; i < n - 1; i++) {
    for (let j = 0; j < n - 1 - i; j++) {
      if (arr[j] > arr[j + 1]) {
        [arr[j], arr[j + 1]] = [arr[j + 1], arr[j]]; // 交换元素
      }
    }
  }
  return arr;
}

// 示例
console.log(bubbleSort([5, 3, 8, 4, 2])); // 输出: [2, 3, 4, 5, 8]

2. 选择排序(Selection Sort)

选择排序是一种简单的排序算法,通过反复地从未排序部分选择最小的元素,并将其放到已排序部分的末尾来排序。

javascript 复制代码
function selectionSort(arr) {
  const n = arr.length;
  for (let i = 0; i < n - 1; i++) {
    let minIndex = i;
    for (let j = i + 1; j < n; j++) {
      if (arr[j] < arr[minIndex]) {
        minIndex = j;
      }
    }
    if (minIndex !== i) {
      [arr[i], arr[minIndex]] = [arr[minIndex], arr[i]]; // 交换元素
    }
  }
  return arr;
}

// 示例
console.log(selectionSort([5, 3, 8, 4, 2])); // 输出: [2, 3, 4, 5, 8]

3. 插入排序(Insertion Sort)

插入排序是一种简单的排序算法,通过构建有序序列,对于未排序数据,在已排序序列中从后向前扫描,找到相应位置并插入。

javascript 复制代码
function insertionSort(arr) {
  const n = arr.length;
  for (let i = 1; i < n; 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;
}

// 示例
console.log(insertionSort([5, 3, 8, 4, 2])); // 输出: [2, 3, 4, 5, 8]

4. 归并排序(Merge Sort)

归并排序是一种分治算法,将数组分成两个子数组,分别排序,然后合并两个已排序的子数组。

javascript 复制代码
function mergeSort(arr) {
  if (arr.length <= 1) {
    return arr;
  }
  const mid = Math.floor(arr.length / 2);
  const left = mergeSort(arr.slice(0, mid));
  const right = mergeSort(arr.slice(mid));
  return merge(left, right);
}

function merge(left, right) {
  const 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);
}

// 示例
console.log(mergeSort([5, 3, 8, 4, 2])); // 输出: [2, 3, 4, 5, 8]

5. 快速排序(Quick Sort)

快速排序是一种分治算法,通过选择一个基准元素,将数组分成两部分,一部分小于基准元素,另一部分大于基准元素,然后递归地排序两部分。

javascript 复制代码
function quickSort(arr) {
  if (arr.length <= 1) {
    return arr;
  }
  const pivot = arr[Math.floor(arr.length / 2)];
  const left = [];
  const right = [];
  for (let i = 0; i < arr.length; i++) {
    if (i === Math.floor(arr.length / 2)) continue;
    if (arr[i] < pivot) {
      left.push(arr[i]);
    } else {
      right.push(arr[i]);
    }
  }
  return quickSort(left).concat(pivot, quickSort(right));
}

// 示例
console.log(quickSort([5, 3, 8, 4, 2])); // 输出: [2, 3, 4, 5, 8]

6. 堆排序(Heap Sort)

堆排序是一种基于堆数据结构的排序算法,利用堆的性质进行排序。

javascript 复制代码
function heapSort(arr) {
  const n = arr.length;

  // 构建最大堆
  for (let i = Math.floor(n / 2) - 1; i >= 0; i--) {
    heapify(arr, n, i);
  }

  // 逐个从堆中取出元素
  for (let i = n - 1; i > 0; i--) {
    [arr[0], arr[i]] = [arr[i], arr[0]]; // 交换元素
    heapify(arr, i, 0);
  }

  return arr;
}

function heapify(arr, n, i) {
  let largest = i;
  const left = 2 * i + 1;
  const right = 2 * i + 2;

  if (left < n && arr[left] > arr[largest]) {
    largest = left;
  }

  if (right < n && arr[right] > arr[largest]) {
    largest = right;
  }

  if (largest !== i) {
    [arr[i], arr[largest]] = [arr[largest], arr[i]]; // 交换元素
    heapify(arr, n, largest);
  }
}

// 示例
console.log(heapSort([5, 3, 8, 4, 2])); // 输出: [2, 3, 4, 5, 8]

总结

这些排序算法各有优缺点,适用于不同的场景:

  • 冒泡排序:简单但效率低,适用于小规模数据。
  • 选择排序:简单但效率低,适用于小规模数据。
  • 插入排序:简单且在部分有序数据中表现较好。
  • 归并排序:稳定且效率高,适用于大规模数据。
  • 快速排序:效率高但不稳定,适用于大规模数据。
  • 堆排序:效率高且不稳定,适用于大规模数据。

通过理解和实现这些排序算法,可以更好地掌握算法的基本原理和应用场景。

相关推荐
DoraBigHead38 分钟前
小哆啦解题记——异位词界的社交网络
算法
web守墓人40 分钟前
【前端】ikun-markdown: 纯js实现markdown到富文本html的转换库
前端·javascript·html
木头左2 小时前
逻辑回归的Python实现与优化
python·算法·逻辑回归
lifallen6 小时前
Paimon LSM Tree Compaction 策略
java·大数据·数据结构·数据库·算法·lsm-tree
秋田君6 小时前
深入理解JavaScript设计模式之命令模式
javascript·设计模式·命令模式
风吹落叶花飘荡7 小时前
2025 Next.js项目提前编译并在服务器
服务器·开发语言·javascript
yanlele8 小时前
我用爬虫抓取了 25 年 6 月掘金热门面试文章
前端·javascript·面试
web_Hsir8 小时前
vue3.2 前端动态分页算法
前端·算法
烛阴9 小时前
WebSocket实时通信入门到实践
前端·javascript
草巾冒小子9 小时前
vue3实战:.ts文件中的interface定义与抛出、其他文件的调用方式
前端·javascript·vue.js