js算法面试题（附答案）

js算法面试题十道

1. 两数之和

题目：给定一个整数数组 nums 和一个目标值 target，请你在该数组中找出和为目标值的那两个整数，并返回他们的数组下标。

function twoSum(nums, target) {
  const map = new Map();
  for (let i = 0; i < nums.length; i++) {
    const complement = target - nums[i];
    if (map.has(complement)) {
      return [map.get(complement), i];
    }
    map.set(nums[i], i);
  }
  return [];
}

2. 反转字符串

题目：给你一个字符串 s，请你将它反转成一个新的字符串。

function reverseString(s) {
  return s.split('').reverse().join('');
}

3. 最长公共子序列

题目：给定两个字符串 text1 和 text2，返回这两个字符串的最长公共子序列的长度。

function longestCommonSubsequence(text1, text2) {
  const m = text1.length;
  const n = text2.length;
  const dp = Array.from({ length: m + 1 }, () => Array(n + 1).fill(0));
  for (let i = 1; i <= m; i++) {
    for (let j = 1; j <= n; j++) {
      if (text1[i - 1] === text2[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];
}

4. 合并两个有序数组

题目：给你两个有序整数数组 nums1 和 nums2，请你将它们合并成一个的新数组。你可以假设这个新数组的长度一定小于或等于 nums1.length + nums2.length。

function mergeTwoArrays(nums1, nums2) {
  const result = [];
  let i = 0;
  let j = 0;
  while (i < nums1.length && j < nums2.length) {
    if (nums1[i] < nums2[j]) {
      result.push(nums1[i]);
      i++;
    } else {
      result.push(nums2[j]);
      j++;
    }
  }
  return result.concat(nums1.slice(i)).concat(nums2.slice(j));
}

5. 三数之和

题目：给你一个包含 n 个整数的数组 nums，判断是否可以通过在数组中选择一个起始点，然后向后选择两个整数，使得这三个整数的和等于目标值。

function threeSum(nums, target) {
  const result = [];
  nums.sort((a, b) => a - b);
  for (let i = 0; i < nums.length - 2; i++) {
    if (i > 0 && nums[i] === nums[i - 1]) continue;
    const left = i + 1;
    const right = nums.length - 1;
    while (left < right) {
      const sum = nums[i] + nums[left] + nums[right];
      if (sum === target) {
        result.push([nums[i], nums[left], nums[right]]);
        left++;
        right--;
        while (left < right && nums[left] === nums[left - 1]) left++;
        while (left < right && nums[right] === nums[right + 1]) right--;
      } else if (sum < target) {
        left++;
      } else {
        right--;
      }
    }
  }
  return result;
}

6. 四数之和

题目：给你一个包含 n 个整数的数组 nums，判断是否可以使用其中的四个数来组成一个矩形。如果可以，返回 true；否则，返回 false。

function fourSum(nums, target) {
  const result = [];
  nums.sort((a, b) => a - b);
  for (let i = 0; i < nums.length - 3; i++) {
    if (i > 0 && nums[i] === nums[i - 1]) continue;
    for (let j = i + 1; j < nums.length - 2; j++) {
      if (j > i + 1 && nums[j] === nums[j - 1]) continue;
      const left = j + 1;
      const right = nums.length - 1;
      while (left < right) {
        const sum = nums[i] + nums[j] + nums[left] + nums[right];
        if (sum === target) {
          result.push([nums[i], nums[j], nums[left], nums[right]]);
          left++;
          right--;
          while (left < right && nums[left] === nums[left - 1]) left++;
          while (left < right && nums[right] === nums[right + 1]) right--;
        } else if (sum < target) {
          left++;
        } else {
          right--;
        }
      }
    }
  }
  return result;
}

7. 两数之和 II - 输入有序数组

题目：给定一个已排序的整数数组 nums，找出两个数满足它们的和等于目标值 target。你只能使用每个元素一次。

function twoSumSorted(nums, target) {
  const map = new Map();
  for (let i = 0; i < nums.length; i++) {
    const complement = target - nums[i];
    if (map.has(complement)) {
      return [map.get(complement), i];
    }
    map.set(nums[i], i);
  }
  return [];
}

8. 最大矩形面积

题目：给定一个二维数组 heights，其中 heights[i] 表示第 i 行的高度，返回能够勾勒出的最大矩形面积。

function largestRectangleArea(heights) {
  const stack = [];
  heights.push(0);
  let maxArea = 0;
  for (let i = 0; i < heights.length; i++) {
    while (stack.length && heights[stack[stack.length - 1]] > heights[i]) {
      const height = heights[stack.pop()];
      const width = stack.length === 0 ? i : i - stack[stack.length - 1] - 1;
      maxArea = Math.max(maxArea, height * width);
    }
    stack.push(i);
  }
  return maxArea;
}

9. 盛最多水的容器

题目：给定 n 个非负整数 a1、a2、…、an，请计算连乘这些整数所得到的积，并以字符串形式输出。

function multiply(nums) {
  let result = '1';
  for (const num of nums) {
    result = BigInt(result) * BigInt(num);
  }
  return result.toString();
}

10. 单词拆分 II

题目：给定一个非空字符串 s 和一个定义好的分隔符集合 nonWordChars，返回所有可能的句子排列。句子是由空格分隔的单词组成的。换句话说，要生成所有可能的句子，可以使用回溯算法进行求解。

function wordBreak(s, wordDict) {
  const result = [];
  const memo = new Map();

  function backtrack(start) {
    if (memo.has(start)) {
      return memo.get(start);
    }
    if (start === s.length) {
      result.push('');
      return;
    }
    for (let end = start + 1; end <= s.length; end++) {
      if (wordDict.has(s.slice(start, end))) {
        backtrack(end);
        if (end !== start + 1) {
          const sentences = result.pop();
          result.push(sentences + ' ' + s.slice(start, end));
        } else {
          result.push(s.slice(start, end));
        }
      }
    }
    memo.set(start, result);
    return result;
  }

  backtrack(0);
  return result;
}

再来十道经典面试题

以下是几个经典的 JavaScript 算法题和它们的详细答案：

1. 冒泡排序
   问题：请用 JavaScript 实现一个冒泡排序算法。

function bubbleSort(arr) {
    let 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]) {
                let temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
    }
    return arr;
}

2. 二分查找
   问题：请用 JavaScript 实现一个二分查找算法。

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

3. 深度优先搜索
   问题：请用 JavaScript 实现一个深度优先搜索算法，用于遍历图或树。

function dfs(graph, start, visited = []) {
    visited.push(start);
    console.log(start);
    for (let next of graph[start]) {
        if (!visited.includes(next)) {
            dfs(graph, next, visited);
        }
    }
}

4. 广度优先搜索
   问题：请用 JavaScript 实现一个广度优先搜索算法，用于遍历图或树。

function bfs(graph, start, visited = []) {
    const queue = [start];
    while (queue.length > 0) {
        const node = queue.shift();
        if (!visited.includes(node)) {
            visited.push(node);
            console.log(node);
            for (const next of graph[node]) {
                queue.push(next);
            }
        }
    }
}

5. 归并排序
   问题：请用 JavaScript 实现一个归并排序算法。

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);  // 合并两个有序数组，产生一个新的有序数组。需要额外实现 merge 函数。
 }


function merge(left, right) {
    let result = [];
    let i = 0;
    let j = 0;

    while (i < left.length && j < right.length) {
        if (left[i] < right[j]) {
            result.push(left[i]);
            i++;
        } else {
            result.push(right[j]);
            j++;
        }
    }

    // 如果左边数组还有剩余元素，将其全部加入结果数组
    while (i < left.length) {
        result.push(left[i]);
        i++;
    }

    // 如果右边数组还有剩余元素，将其全部加入结果数组
    while (j < right.length) {
        result.push(right[j]);
        j++;
    }

    return result;
}

在这个实现中，我们首先创建一个空的结果数组。然后我们使用两个指针 i 和 j 分别指向左数组和右数组的第一个元素。我们比较两个指针所指的元素，并将较小的元素推入结果数组。这个过程一直持续到我们遍历完左数组和右数组的所有元素。然后，我们将剩余的元素（如果有的话）添加到结果数组中。最后，我们返回结果数组。

6. 快速排序
   问题：请用 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++) {
        if (arr[i] < pivot) {
            left.push(arr[i]);
        } else {
            right.push(arr[i]);
        }
    }
    return [...quickSort(left), pivot, ...quickSort(right)];
}

7. 插入排序
   问题：请用 JavaScript 实现一个插入排序算法。
   答案：

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

8. 选择排序
   问题：请用 JavaScript 实现一个选择排序算法。
   答案：

function selectionSort(arr) {
    let len = arr.length;
    for (let i = 0; i < len - 1; i++) {
        let minIndex = i;
        for (let j = i + 1; j < len; j++) {
            if (arr[j] < arr[minIndex]) {
                minIndex = j;
            }
        }
        if (minIndex != i) {
            [arr[i], arr[minIndex]] = [arr[minIndex], arr[i]]; // Swap arr[i] and arr[minIndex]
        }
    }
    return arr; // 返回排序后的数组，从小到大排序。
}

9. Fibonacci序列：问题：请用JavaScript实现一个函数，计算Fibonacci序列的第n个数字。答案：

function fibonacci(n) {
    if (n <= 1) {
        return n;
    }
    return fibonacci(n - 1) + fibonacci(n - 2);
}

10. 二分查找改进版：问题：请用JavaScript实现一个函数，在有序数组中查找特定元素，并返回其索引。如果元素不存在，则返回-1。答案：

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