前端常见算法

一、常见的前端算法

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;
}

• 选择排序：

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;
}

• 插入排序：

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

2、搜索算法

搜索算法是前端算法中另一个常见的分类。常用的搜索算法包括二分查找、广度优先搜索、深度优先搜索等。
这些算法适用于不同的场景，例如在已排序的数组中查找单个元素时可以使用二分查找，而在寻找最短路径时则可以使用广度优先搜索。

下面是一些常见的搜索算法的实现方法：

• 二分查找：

function binarySearch(arr, target) {
  let left = 0;
  let right = arr.length - 1;
  while (left <= right) {
    let 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;
}

• 广度优先搜索：

function bfs(graph, start) {
  let queue = [start];
  let visited = new Set();
  visited.add(start);
  while (queue.length > 0) {
    let node = queue.shift();
    console.log(node);
    for (let neighbor of graph[node]) {
      if (!visited.has(neighbor)) {
        queue.push(neighbor);
        visited.add(neighbor);
      }
    }
  }
}

• 深度优先搜索：

function dfs(graph, start, visited) {
  visited.add(start);
  console.log(start);
  for (let neighbor of graph[start]) {
    if (!visited.has(neighbor)) {
      dfs(graph, neighbor, visited);
    }
  }
}

3、动态规划算法

动态规划算法是一种重要的算法思想，它可以用来解决很多实际问题，例如编辑距离问题、背包问题等。
在前端开发中，动态规划算法可以用来解决一些复杂的布局和逻辑问题。

下面是一个使用动态规划算法解决编辑距离问题的实现方法：

function editDistance(str1, str2) {
  let m = str1.length;
  let n = str2.length;
  let dp = Array.from({ length: m + 1 }, () => Array.from({ length: n + 1 }, () => 0));
  for (let i = 1; i <= m; i++) {
    dp[i][0] = i;
  }
  for (let j = 1; j <= n; j++) {
    dp[0][j] = j;
  }
  for (let i = 1; i <= m; i++) {
    for (let j = 1; j <= n; j++) {
      if (str1[i - 1] === str2[j - 1]) {
        dp[i][j] = dp[i - 1][j - 1];
      } else {
        dp[i][j] = Math.min(dp[i - 1][j], dp[i][j - 1], dp[i - 1][j - 1]) + 1;
      }
    }
  }
  return dp[m][n];
}

4、贪心算法

贪心算法是一种简单而高效的算法思想，它通常用来解决一些最优化问题，例如霍夫曼编码问题、活动选择问题等。
虽然贪心算法存在一定的局限性，但是在一些实际问题中，它可以提供高效的解决方案。

下面是一个使用贪心算法解决活动选择问题的实现方法：

function greedyActivitySelector(s, f) {
  let n = s.length;
  let i = 0;
  let result = [i];
  for (let j = 1; j < n; j++) {
    if (s[j] >= f[i]) {
      result.push(j);
      i = j;
    }
  }
  return result;
}

6、字符串算法

字符串算法是一种特殊的算法，它主要用来解决与字符串相关的问题，例如字符串匹配、最长公共子序列、最长回文子串等问题。
在前端开发中，字符串算法可以用来处理文本和字符串数据。

下面是一个使用动态规划算法求解最长公共子序列的实现方法：

function longestCommonSubsequence(str1, str2) {
  let m = str1.length;
  let n = str2.length;
  let dp = Array.from({ length: m + 1 }, () => Array.from({ length: n + 1 }, () => 0));
  for (let i = 1; i <= m; i++) {
    for (let j = 1; j <= n; j++) {
      if (str1[i - 1] === str2[j - 1]) {
        dp[i][j] = dp[i - 1][j - 1] + 1;
      } else {
        dp[i][j] = Math.max(dp[i - 1][j], dp[i][j - 1]);
      }
    }
  }
  return dp[m][n];
}

7、数学算法

数学算法是一种特殊的算法，它主要用来解决与数学相关的问题，例如质因数分解、素数判断、最大公约数和最小公倍数等问题。
在前端开发中，数学算法可以用来处理与数字相关的问题。

下面是一个求解最大公约数和最小公倍数的实现方法：

function gcd(a, b) {
  return b === 0 ? a : gcd(b, a % b);
}

function lcm(a, b) {
  return (a * b) / gcd(a, b);
}

其他算法

另外，还有一些其他类型的算法也常常被用到，例如递归算法、回溯算法、分治算法等。这些算法都有各自的特点和适用场景，在实际开发过程中需要根据具体问题来选择合适的算法。