LeetCode 2016. 增量元素之间的最大差值

  1. 暴力双重循环

    1. var maximumDifference = function (nums) {
    2. let max = -Infinity;
    3. for (let i = 0; i < nums.length; i++) {
    4.  for (let j = i + 1; j < nums.length; j++) {
    5.    if (nums[j] - nums[i] > max && nums[j] > nums[i]) {
    6.      max = nums[j] - nums[i];
    7.    }
    8.  }
    9. }
    10. if (max === -Infinity) {
    11.  return -1;
    12. }
    13. return max;
    14. };

    LeetCode 2239. 找到最接近 0 的数字

  2. 循环判断绝对值

用两个变量，一个保存原值，一个保存绝对值。nums[0]做初始绝对值，遍历数组对比初始绝对值，小就更新原值和绝对值，相等且原值大于0，就更新原值，原值小于0，不更新，因为要返回满足条件的最大值。

  1. var findClosestNumber = function (nums) {
  2.     let n = nums[0];
  3.     let absN = Math.abs(nums[0]);
  4.     for (let i = 0; i < nums.length; i++) {
  5.         if (Math.abs(nums[i]) < absN) {
  6.             n = nums[i]
  7.             absN = Math.abs(nums[i])
  8.         } else if (Math.abs(nums[i]) === absN && nums[i] > 0) {
  9.             n = Math.abs(nums[i]);
  10.         }
  11.     }
  12.     return n;
  13. };

LeetCode 1475. 商品折扣后的最终价格

  1. 双重循环

读懂题，然后双重循环，问题不大

  1. var finalPrices = function (prices) {
  2.     for (let i = 0; i < prices.length; i++) {
  3.         for (let j = i + 1; j < prices.length; j++) {
  4.             if (prices[j] <= prices[i]) {
  5.                 prices[i] = prices[i] - prices[j]
  6.                 break
  7.             }
  8.         }
  9.     }
  10.     return prices;
  11. };

  1. 单调栈

    LeetCode 2248. 多个数组求交集

  2. hashmap

根据提示是每个数组中的值不会出现重复的，同时要求所有数组都出现过的，因此很简单
首先定义一个hashmap，统计所有数字出现的次数
从中过滤出出现次数符合nums的长度的，证明这些数字每个数组都出现过，否则肯定不够
然后排序返回即可

  1. var intersection = function (nums) {
  2.   const map = {}
  3.   //map的键记录数组中的值，map的值记录出现的次数
  4.   const length = nums.length
  5.   nums.forEach(item => {
  6.     item.forEach(c => {
  7.       if (!map[c]) {
  8.         map[c] = 1
  9.       } else {
  10.         map[c]++
  11.       }
  12.     })
  13.   })
  14.   return Object.entries(map).filter(item => item[1] === length).map(item => item[0]).sort((a, b) => a - b)
  15.   //先将对象转为二维数组，[["键","值"],["键","值"]]的形式，过滤取掉长度满足nums.length的。
  16.   //然后把键取出来进行排序，就形成了要返回的一维数组
  17. };

LeetCode 34. 在排序数组中查找元素的第一个和最后一个位置

  1. 两个二分法分别寻找左右边界，注意，左边界从右侧逼近，有边界从左侧逼近
    1. var searchRange = function (nums, target) {
    2.  const getLeftBorder = (nums, target) => {
    3.      let left = 0, right = nums.length - 1
    4.      let leftBorder = -2
    5.      while (left <= right) {
    6.          let middle = left + ((right - left) >> 1)
    7.          if (nums[middle] >= target) {
    8.              right = middle - 1
    9.              leftBorder = right
    10.              //右侧逼近找左边界，算出来的边界不包含真正的边界，需+1
    11.          } else {
    12.              left = middle + 1
    13.          }
    14.      }
    15.      return leftBorder
    16.  }
    17.  const getRightBorder = (nums, target) => {
    18.      let left = 0, right = nums.length - 1
    19.      let rightBorder = -2
    20.      while (left <= right) {
    21.          let middle = left + ((right - left) >> 1)
    22.          if (nums[middle] > target) {
    23.              right = middle - 1
    24.          } else {
    25.              left = middle + 1
    26.              rightBorder = left
    27.              //左侧逼近右边界，算出来的边界不包含真正的边界，需-1
    28.          }
    29.      }
    30.      return rightBorder
    31.  }
    32.  let leftBorder = getLeftBorder(nums, target)
    33.  let rightBorder = getRightBorder(nums, target)
    34.  if (leftBorder === -2 || rightBorder === -2) return [-1, -1]
    35.  if (rightBorder - leftBorder > 1) return [leftBorder + 1, rightBorder - 1]
    36.  return [-1, -1]
    37. };