Leetcode 算法题合集

1. 罗马数字转整数

如图：输入 I，返回 1；输入 IV，返回 4…

const obj = {
  'I': 1,
  'V': 5,
  'X': 10,
  'L': 50,
  'C': 100,
  'D': 500,
  'M': 1000
}
function romanToInt(s) {
  const length = s.length
  let result = 0
  for (let i = 0; i < length; i++) {
    const front = s[i]
    const back = s[i + 1]
    if (obj[back] > obj[front]) {
      result -= obj[front]
    } else {
      result += obj[front]
    }
  }
  return result
}
const a = romanToInt('MMDC')
const b = romanToInt('DXI')
const c = romanToInt('V')
console.log(a, b, c) // 2600 511 5

2. 整数反转

function reverseInt(x) {
  const min = Math.pow(-2, 31)
  const max = Math.pow(2, 31)
  const sign = Math.sign(x)
  x = Math.abs(x)

  let result = 0
  let remainder = 0
  while (x > 0) {
    remainder = x % 10
    x = (x - remainder) / 10
    result = result * 10 + remainder
  }

  result *= sign

  if (result < min || result > max) return 0
  return result
}

const a = reverseInt(123)
const b = reverseInt(-45678)
console.log(a, b) // 321 -87654

3. 两数之和

const nums = [2, 7, 11, 15]
const target = 26

function twoSum(nums, target) {
  const box = new Map()
  for (let i = 0; i < nums.length; i++) {
    if (box[target - nums[i]] >= 0) {
      return [box[target - nums[i]], i]
    }
    // 以数组的值为键,索引为值存储到新对象
    box[nums[i]] = i
  }
}
console.log(twoSum(nums, target)) // [2, 3]

4. 删除排序数组的重复项

// 遍历移除法
const nums = [1, 1, 2]

for (let i = 0; i < nums.length; i++) {
  if (nums[i] === nums[i + 1]) {
    nums.splice(i, 1)
    i--
  }
}

console.log(nums) // [1, 2]
console.log(nums.length) // 2

// 双指针法
const nums = [2, 2, 4, 4, 4, 6]
let length = 0

for (let father = 0, child = 0; father < nums.length; father++) {
  if (nums[child] !== nums[father]) {
    child++
    nums[child] = nums[father]
  }
  length = child
}
console.log(nums) // [2, 4, 6, 4, 4, 6]
console.log(length + 1) // 3

5. 统计素数

// 暴力算法
function statisticalPrime(n) {
  let count = 0
  for (let i = 2; i <= n; i++) {
    count += isPrime(i) ? 1 : 0
  }
  return count
}

function isPrime(x) {
  // 一个数若可以进行因素分解，那么分解时得到的两个数一定是一个小于等于 sqrt(x)，一个大于等于 sqrt(x)
  // 例如 16 拆成 2 * 8 或 4 * 4 都满足上述条件，所以在遍历的时候只需到 x 的平方根
  for (let i = 2; i * i <= x; i++) {
    if (x % i === 0) {
      return false
    }
  }
  return true
}
console.log(statisticalPrime(10)) // 4
console.log(statisticalPrime(100)) // 25

// 埃筛法 筛选合数，减少遍历次数
function statisticalPrime(n) {
  const primes = Array.from({ length: n }, () => true) // 将素数标记为 true
  let count = 0
  for (let i = 2; i < n; i++) {
    if (primes[i]) {
      count++
      for (let j = i * i; j < n; j += i) {
        primes[j] = false // 将合数标记为 false
      }
    }
  }
  return count
}
console.log(statisticalPrime(10)) // 4
console.log(statisticalPrime(100)) // 25

6. 无重复字符的最长字串

输入 ‘abcabcbb’, 最长 ‘abc’, 输出 3
输入 ‘pwwkew’, 最长 ‘kew’, 输出 3

function lengthOfLongestSubstring(s) {
  const set = new Set()
  let maxLength = 0
  
  for (let i = 0, j = 0; i < s.length; i++) {
    const curr = s[i]

    if (!set.has(curr)) {
      set.add(curr)
      maxLength = Math.max(maxLength, set.size)
    } else {
      while (set.has(curr)) {
        set.delete(s[j])
        j++
      }
      set.add(curr)
    }
  }
  return maxLength
}


console.log(lengthOfLongestSubstring('abcabcbb')) // 3
console.log(lengthOfLongestSubstring('pwwkew')) // 3

7. 最长回文字符串

输入 ‘babad’, 输出 ‘bab’
输入 ‘cbbd’, 输出 ‘bb’

/* 解题步骤
 * 1. 如果字符串长度小于 2, 直接返回字符串
 * 2. 定义两个变量, 一个 start 存储当前找到的最大回文字符串的起始位置, 另一个 maxLength 记录字符串的长度
 * 3. 创建一个 helper function, 判断左边和右边是否越界, 同时最左边的字符是否等于最右边的字符
   *  如果三个条件都满足, 则判断是否需要更新回文字符串最大长度及最大字符串的起始位置
   *  然后将 left--, right++, 继续判断, 直到不满足三个条件之一  
 * 4. 遍历字符串, 每个位置调用 helper function 两遍。第一遍检查 i-1, i+1; 第二遍检查 i, i+1
*/

function longestPalindrome(s) {
  if (s.length < 2) return s

  let start = 0
  let maxLength = 1

  function exoandAroundCenter(left, right) {
    while (left >= 0 && right < s.length && s[left] === s[right]) {
      if (right - left + 1 > maxLength) {
        maxLength = right - left + 1
        start = left
      }
      left--
      right++
    }
  }

  for (let i = 0; i < s.length; i++) {
    exoandAroundCenter(i - 1, i + 1)
    exoandAroundCenter(i, i + 1)
  }

  return s.substr(start, maxLength)
}

console.log(longestPalindrome('babad')) // bab
console.log(longestPalindrome('cbbd')) // bb

8. 三数之和

输入一个有序数组 [-4, -1, -1, 0, 1, 2], 计算三数之和等于0, 输出 [[-1, 0, 1], [-1, -1, 2]]
注意不能出现相同的数组

function threeSum(nums) {
  const result = []

  for (let i = 0; i < 4; i++) {
    if (i !== 0 && nums[i] === nums[i - 1]) continue

    let start = i + 1, end = nums.length - 1
    while(start < end) {
      let sum = nums[i] + nums[start] + nums[end]
      if (sum === 0) {
        result.push([nums[i], nums[start], nums[end]])
        start++
        end--
        while(start < end && nums[start] === nums[start - 1]) {
          start++
        }
        while(start < end && nums[end] === nums[end + 1]) {
          end--
        }
      } else if (sum > 0) {
        end--
      } else {
        start++
      }
    }
  }

  return result
}

console.log(threeSum([-4, -1, -1, 0, 1, 2])) // [[-1, -1, 2], [-1, 0, 1]]

9. 有效的括号

输入 ‘({}[]){}’, 输出 true
输入 ‘{}()[’, 输出 false

解题步骤

1. 创建一个 HashMap，把括号配对放进去
2. 创建一个 stack(array)，for 循环遍历字符串，对于每一个字符
   • 如果 map 里有这个 key，那说明它是个左括号，从 map 里取得相对应的右括号，把它 push 进 stack 里
   • 否则的话，它就是右括号，需要 pop 出 stack 里的第一个字符，然后看它是否等于当前的字符。如果不相符，则返回 false
3. 循环结束后，如果 stack 不为空，说明还剩下左括号没有被闭合，返回 false。否则返回 true

function isValid(s) {
  const map = new Map()

  map.set('(', ')')
  map.set('{', '}')
  map.set('[', ']')

  const stack = []

  for (let i = 0; i < s.length; i++) {
    if (map.has(s[i])) {
      stack.push(map.get(s[i]))
    } else {
      if (stack.pop() !== s[i]) {
        return false
      }
    }
  }

  if (stack.length) return false

  return true
}

console.log(isValid('({}[]){}')) // true
console.log(isValid('{}()[') // false

10. 反转链表

function ListNode(val) {
  this.val = val
  this.next = null
}

function reverseList(head) {
  // 1.创建两个变量,一个是未反转的链表指针,另一个是反转后的链表
  let cur = head
  let prev = null
  
  // 2.递归遍历未反转的链表
  while (cur) {
    // 3.修改 next 指针，并且当前链表指针向前继续遍历,直到 next 等于 null
    const tmp = cur.next
    cur.next = prev
    prev = cur
    cur = tmp
  }
  
  return prev
}

11. Group Anagrams

/*
 * 1.检查数组是否为空数组
 * 2.遍历字符串数组
 * 3.建立一个长度为26的数组，起始值为0;建立一个 hashMap
 *   字母每出现一次,对应索引就加一；a -> 0、b -> 1、c -> 2 ......
 * 4.遍历数组的字符串,将字母的出现频率放到数组的对应位置里
 *   利用 ascii 码, a -> 97、b -> 98、c -> 99 ......
 * 5.将长度为26的数组转成字符串当 map 的 key
 * 6.判断 key 是否存在
 *   存在：合并
 *   不存在：直接添加
 * 7.遍历map，将结果返回 
 */
function groupAnagrams(strs) {
  if (!strs.length) return []

  const map = new Map()
  for (const str of strs) {
    const characters = Array(26).fill(0)

    for (let i = 0; i < str.length; i++) {
      const ascii = str.charCodeAt(i) - 97
      characters[ascii]++
    }

    const key = characters.join('')
    if (map.has(key)) {
      map.set(key, [...map.get(key), str])
    } else {
      map.set(key, [str])
    }
  }
  const result = []
  for (const value of map.values()) {
    result.push(value)
  }

  return result
}

12. 最大子序和

function maxSubArray(nums) {
  const memo = []
  memo[0] = nums[0]

  for (let i = 1; i < nums.length; i++) {
    memo[i] = Math.max(nums[i] + memo[i - 1], nums[i])
  }

  const max = Math.max.apply(null, memo)

  return max
}

console.log(maxSubArray([1, -3, 4, -1, 2, 1, -5, 4])) // 6

13. 不同路径

function uniquePaths(m, n) {
  const memo = []

  // 1. push 二维数组, m 为横轴
  for (let i = 0; i < m; i++) {
    memo.push([])
  }

  // 2. 横向填充 1
  for (let row = 0; row < m; row++) {
    memo[row][0] = 1
  }

  // 3. 纵向填充 1
  for (let col = 0; col < n; col++) {
    memo[0][col] = 1
  }

  // 4. 填充每个格子数
  for (let row = 1; row < m; row++) {
    for (let col = 1; col < n; col++) {
      memo[row][col] = memo[row - 1][col] + memo[row][col - 1]
    }
  }

  // 5. 求最大值
  return memo[m - 1][n - 1]
}

console.log(uniquePaths(3, 2)) // 3
console.log(uniquePaths(7, 3)) // 28

14. 爬楼梯

function climbStairs(n) {
  // 1. 初始化
  const memo = [0, 1, 2]

  // 2. 根据规律,后面的每一项都等于前两项之和
  for (let i = 3; i <= n; i++) {
    memo[i] = memo[i - 2] + memo[i - 1]
  }

  return memo[n]
}

console.log(climbStairs(2)) // 2
console.log(climbStairs(3)) // 3

15. 求子集

function subSets(nums) {
  const result = []

  function backtrack(start, curr) {
    // 1. 把 curr 添加到 result
    result.push([...curr])
    // 2. 循环
    for (let i = start, len = nums.length; i < len; i++) {
      // 2.1 把numsi]加入curr数组
      curr.push(nums[i])
      // 2.2 backtrack(i+1,curr)
      backtrack(i + 1, curr)
      // 2.3 把curr数组的最后一个元素移除
      curr.pop()
    }
  }

  backtrack(0, [])
  return result
}

console.log(JSON.stringify(subSets([1, 2, 3]))) // [[],[1],[1,2],[1,2,3],[1,3],[2],[2,3],[3]]