前端基础常见的算法

你整理的这些前端常见算法知识点挺实用的，适合复习或面试准备。下面我帮你稍微整理美化一下格式，并补充一点细节，让内容更清晰易读：

1. 排序算法

• 冒泡排序（Bubble Sort）
  原理：通过重复比较相邻元素并交换位置，将最大（或最小）的元素逐步“冒泡”到数组的末尾。
  时间复杂度：平均和最坏为 O(n²)，最好情况（已经有序）为 O(n)。

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

• 快速排序（Quick Sort）
  原理：选择一个基准元素（pivot），将数组分成小于和大于基准的两部分，递归排序。
  时间复杂度：平均 O(n log n)，最坏 O(n²)。

  function quickSort(arr) {
    if (arr.length <= 1) return arr;
    const pivot = arr[0];
    const left = arr.slice(1).filter(item => item < pivot);
    const right = arr.slice(1).filter(item => item >= pivot);
    return [...quickSort(left), pivot, ...quickSort(right)];
  }
  

2. 搜索算法

• 线性搜索（Linear Search）
  原理：从头开始逐个比较，直到找到目标或遍历结束。
  时间复杂度：O(n)

  function linearSearch(arr, target) {
    for (let i = 0; i < arr.length; i++) {
      if (arr[i] === target) return i;
    }
    return -1;
  }
  

• 二分搜索（Binary Search） （适用于有序数组）
  原理：每次将数组一分为二，根据中间值判断目标在左侧还是右侧，缩小范围。
  时间复杂度：O(log n)

  function binarySearch(arr, target) {
    let left = 0, right = arr.length - 1;
    while (left <= right) {
      const mid = Math.floor((left + right) / 2);
      if (arr[mid] === target) return mid;
      else if (arr[mid] < target) left = mid + 1;
      else right = mid - 1;
    }
    return -1;
  }
  

3. 字符串算法

• 字符串匹配（BF、KMP）

  • BF（Brute Force，暴力匹配） ：从主串每一个位置开始匹配模式串。时间复杂度 O(mn)。
  • KMP（Knuth-Morris-Pratt）算法：通过前缀表避免重复比较，提高效率。时间复杂度 O(n + m)。

  这里以暴力匹配为例：

  function bruteForceMatch(str, pattern) {
    for (let i = 0; i <= str.length - pattern.length; i++) {
      let j = 0;
      while (j < pattern.length && str[i + j] === pattern[j]) {
        j++;
      }
      if (j === pattern.length) return i;
    }
    return -1;
  }
  

• 字符串反转
  原理：可以使用循环或内置方法来反转字符串。

  • 方法1：循环方式

    function reverseString(str) {
      let reversed = '';
      for (let i = str.length - 1; i >= 0; i--) {
        reversed += str[i];
      }
      return reversed;
    }
    

  • 方法2：内置方法

    const reverseString = str => str.split('').reverse().join('');
    

需要我帮你加上图解、口诀记忆或者继续补充其他常见算法吗？比如递归、动态规划、贪心、DFS/BFS？