AI生成-前端排序算法-Toy模板网

这篇具有很好参考价值的文章主要介绍了AI生成-前端排序算法。希望对大家有所帮助。如果存在错误或未考虑完全的地方，请大家不吝赐教，您也可以点击"举报违法"按钮提交疑问。

前端排序算法是指对一组数据进行排序的算法，常用的有冒泡排序、插入排序、选择排序、快速排序、归并排序等。

1. 冒泡排序（Bubble sort）

冒泡排序是一种简单的排序算法，它重复地走访过要排序的数列，一次比较两个元素，如果它们的顺序错误就交换它们。

冒泡排序的时间复杂度为O(n^2)，不适用于大规模数据的排序。

示例代码：文章来源地址https://www.toymoban.com/news/detail-500322.html

function bubbleSort(array) {
  const length = array.length
  for (let i = 0; i < length - 1; i++) {
    for (let j = 0; j < length - 1 - i; j++) {
      if (array[j] > array[j + 1]) {
        const temp = array[j]
        array[j] = array[j + 1]
        array[j + 1] = temp
      }
    }
  }
  return array
}

2. 插入排序（Insertion sort）

插入排序就是将未排序的元素一个一个插入到已排序的元素中的正确位置，直到所有元素都排序完成。

插入排序的时间复杂度为O(n^2)，稳定的排序算法。

示例代码：

function insertionSort(array) {
  for (let i = 1; i < array.length; i++) {
    let j = i - 1
    const temp = array[i]
    while (j >= 0 && array[j] > temp) {
      array[j + 1] = array[j]
      j--
    }
    array[j + 1] = temp;
  }
  return array
}

3. 选择排序（Selection sort）

选择排序是一种简单直观的排序算法。它的工作原理是每一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，直到全部待排序的数据元素排完。

选择排序的时间复杂度为O(n^2)，不稳定的排序算法。

示例代码：

function selectionSort(array) {
  const length = array.length
  for (let i = 0; i < length - 1; i++) {
    let minIndex = i
    for (let j = i + 1; j < length; j++) {
      if (array[j] < array[minIndex]) {
        minIndex = j
      }
    }
    const temp = array[i]
    array[i] = array[minIndex]
    array[minIndex] = temp
  }
  return array
}

4. 快速排序（Quick sort）

快速排序使用分治法（Divide and conquer）策略来把一个序列分成两个子序列。步骤为：

从数组中挑出一个元素，称为"基准"（pivot）。
将数组中比基准元素大的放置在基准的右边，比基准元素小的放置在基准的左边。
对基准左右两边的子序列进行递归排序。

快速排序的时间复杂度为O(nlogn)，不稳定的排序算法。

示例代码：

function quickSort(array) {
  if (array.length <= 1) {
    return array
  }
  const pivotIndex = Math.floor(array.length / 2)
  const pivot = array.splice(pivotIndex, 1)[0]
  const left = []
  const right = []
  for (let i = 0; i < array.length; i++) {
    if (array[i] < pivot) {
      left.push(array[i])
    } else {
      right.push(array[i])
    }
  }
  return [...quickSort(left), pivot, ...quickSort(right)]
}

5. 归并排序（Merge sort）

归并排序的思想是将一组未排序的数组分成两个子序列，对每个子序列递归地进行排序，然后将结果合并起来。

归并排序的时间复杂度为O(nlogn)，稳定的排序算法。

示例代码：

function mergeSort(array) {
  if (array.length <= 1) {
    return array
  }
  const midIndex = Math.floor(array.length / 2)
  const left = array.slice(0, midIndex)
  const right = array.slice(midIndex)
  return merge(mergeSort(left), mergeSort(right))
}

function merge(left, right) {
  const result = []
  let leftIndex = 0
  let rightIndex = 0
  while (leftIndex < left.length && rightIndex < right.length) {
    if (left[leftIndex] < right[rightIndex]) {
      result.push(left[leftIndex])
      leftIndex++
    } else {
      result.push(right[rightIndex])
      rightIndex++
    }
  }
  return result.concat(left.slice(leftIndex)).concat(right.slice(rightIndex))
}

到了这里，关于AI生成-前端排序算法的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！