当前位置：首页 > JavaScript

用js来实现所有算法

2026-04-04 21:38:46JavaScript

使用JavaScript实现所有算法是一个庞大的任务，因为算法覆盖的范围极广，从基础排序到复杂机器学习算法均可涉及。以下是常见算法分类及部分核心实现示例：

排序算法

快速排序

function quickSort(arr) {
  if (arr.length <= 1) return arr;
  const pivot = arr[0];
  const left = [];
  const right = [];
  for (let i = 1; i < arr.length; i++) {
    arr[i] < pivot ? left.push(arr[i]) : right.push(arr[i]);
  }
  return [...quickSort(left), pivot, ...quickSort(right)];
}

归并排序

用js来实现所有算法

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) {
  let result = [];
  while (left.length && right.length) {
    left[0] < right[0] ? result.push(left.shift()) : result.push(right.shift());
  }
  return [...result, ...left, ...right];
}

搜索算法

二分查找

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

图算法

Dijkstra最短路径

用js来实现所有算法

function dijkstra(graph, start) {
  const distances = {};
  const visited = new Set();
  Object.keys(graph).forEach(node => distances[node] = Infinity);
  distances[start] = 0;

  while (true) {
    let closestNode = null;
    Object.keys(distances).forEach(node => {
      if (!visited.has(node) && (closestNode === null || distances[node] < distances[closestNode])) {
        closestNode = node;
      }
    });

    if (closestNode === null) break;
    visited.add(closestNode);
    Object.keys(graph[closestNode]).forEach(neighbor => {
      const newDistance = distances[closestNode] + graph[closestNode][neighbor];
      if (newDistance < distances[neighbor]) distances[neighbor] = newDistance;
    });
  }
  return distances;
}

动态规划

斐波那契数列（带缓存）

function fibonacci(n, memo = {}) {
  if (n in memo) return memo[n];
  if (n <= 2) return 1;
  memo[n] = fibonacci(n - 1, memo) + fibonacci(n - 2, memo);
  return memo[n];
}

机器学习基础

线性回归梯度下降

function gradientDescent(X, y, learningRate = 0.01, epochs = 1000) {
  let m = X.length;
  let theta0 = 0, theta1 = 0;

  for (let epoch = 0; epoch < epochs; epoch++) {
    let temp0 = 0, temp1 = 0;
    for (let i = 0; i < m; i++) {
      const error = (theta0 + theta1 * X[i]) - y[i];
      temp0 += error;
      temp1 += error * X[i];
    }
    theta0 -= (learningRate * temp0) / m;
    theta1 -= (learningRate * temp1) / m;
  }
  return [theta0, theta1];
}