JavaScript中的常见算法该如何实现

在JavaScript编程中，算法是解决问题的核心逻辑载体，掌握常见算法的实现方式能够帮助开发者更高效地应对各类开发场景。无论是处理数据排序、查找目标元素，还是解决复杂的逻辑问题，合适的算法都能大幅提升代码的执行效率。

排序算法实现

冒泡排序

冒泡排序是最基础的排序算法之一，核心逻辑是重复遍历待排序的数组，每次比较相邻的两个元素，如果顺序错误就交换它们的位置，直到整个数组有序。

// 冒泡排序实现
function bubbleSort(arr) {
  const len = arr.length;
  // 外层循环控制排序轮数
  for (let i = 0; i < len - 1; i++) {
    // 内层循环控制每轮比较次数，每轮后会有一个最大元素沉底
    for (let j = 0; j < len - 1 - i; j++) {
      // 如果前一个元素大于后一个元素，交换位置
      if (arr[j] > arr[j + 1]) {
        const temp = arr[j];
        arr[j] = arr[j + 1];
        arr[j + 1] = temp;
      }
    }
  }
  return arr;
}

// 测试示例
const testArr = [3, 6, 2, 9, 1];
console.log(bubbleSort(testArr)); // 输出 [1, 2, 3, 6, 9]

快速排序

快速排序是效率较高的排序算法，采用分治的思想，选择一个基准元素，将数组分为两部分，一部分的元素都小于基准，另一部分都大于基准，然后递归处理两部分子数组。

// 快速排序实现
function quickSort(arr) {
  // 数组长度小于等于1时直接返回
  if (arr.length <= 1) {
    return arr;
  }
  // 选择中间元素作为基准
  const pivotIndex = Math.floor(arr.length / 2);
  const pivot = arr.splice(pivotIndex, 1)[0];
  const left = [];
  const 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));
}

// 测试示例
const testArr2 = [5, 8, 2, 1, 7, 3];
console.log(quickSort(testArr2)); // 输出 [1, 2, 3, 5, 7, 8]

查找算法实现

线性查找

线性查找是最简单的查找方式，从数组的第一个元素开始，逐个遍历对比目标值，直到找到匹配元素或者遍历完整个数组。

// 线性查找实现
function linearSearch(arr, target) {
  for (let i = 0; i < arr.length; i++) {
    if (arr[i] === target) {
      return i; // 找到目标，返回索引
    }
  }
  return -1; // 未找到，返回-1
}

// 测试示例
const searchArr = [10, 20, 30, 40, 50];
console.log(linearSearch(searchArr, 30)); // 输出 2
console.log(linearSearch(searchArr, 60)); // 输出 -1

二分查找

二分查找适用于有序数组，每次取数组中间的元素和目标值对比，如果中间元素等于目标值就返回，如果中间元素大于目标值就在左半部分查找，否则在右半部分查找，直到找到目标或者查找范围为空。

// 二分查找实现（非递归版本）
function binarySearch(arr, target) {
  let left = 0;
  let right = arr.length - 1;
  while (left <= right) {
    // 计算中间索引，避免 left+right 溢出
    const mid = left + Math.floor((right - left) / 2);
    if (arr[mid] === target) {
      return mid; // 找到目标，返回索引
    } else if (arr[mid] < target) {
      left = mid + 1; // 目标在右半部分，调整左边界
    } else {
      right = mid - 1; // 目标在左半部分，调整右边界
    }
  }
  return -1; // 未找到，返回-1
}

// 测试示例，二分查找要求数组有序
const sortedArr = [1, 3, 5, 7, 9, 11];
console.log(binarySearch(sortedArr, 7)); // 输出 3
console.log(binarySearch(sortedArr, 4)); // 输出 -1

算法选择建议

在实际开发中，需要根据场景选择合适的算法：

• 如果数据量小且对稳定性有要求，可以选择冒泡排序
• 如果数据量大且追求排序效率，快速排序是更好的选择
• 如果数组无序且数据量小，线性查找实现简单
• 如果数组有序且数据量大，二分查找的效率远高于线性查找

掌握这些基础算法的实现逻辑，能够帮助开发者更好地理解JavaScript的运行机制，也能在面试和实际开发中更灵活地解决问题。

JavaScript算法排序算法查找算法修改时间：2026-06-15 17:54:26