30 天刷题挑战（十四）

2722. 根据 ID 合并两个数组

思路

新建一个数组保存结果，依次遍历 arr1，arr2 遇到相同的索引，值合并，最后过滤出真值。

代码

js 复制代码

/**
 * @param {Array} arr1
 * @param {Array} arr2
 * @return {Array}
 */
var join = function(arr1, arr2) {
  const res = []

  for (let item of arr1) {
    res[item.id] = item
  }

  for (let item of arr2) {
    if (res[item.id]) {
      Object.assign(res[item.id], item)
    } else {
      res[item.id] = item
    }
  }

  return res.filter(i => !!i);
};

2625. 扁平化嵌套数组

思路

遍历数组，判断每一项是否是数组，是的话使用 flat 函数递归此项，传入 n - 1，否则直接添加到结果数组。

代码

js 复制代码

/**
 * @param {Array} arr
 * @param {number} depth
 * @return {Array}
 */
var flat = function (arr, n) {
  const res = []
  
  for(let item of arr) {
    if (Array.isArray(item) && n > 0) {
      const ret = flat(item, n - 1)
      res.push(...ret)
    } else {
      res.push(item)
    }
  }

  return res
};

1372. 二叉树中的最长交错路径

思路

深度优先遍历，遍历时每个节点存储达此节点的路径数，结果取最大值。

代码

js 复制代码

var longestZigZag = function(root) {
  let res = 0

  const dfs = (node, l, r) => {
    res = Math.max(res, l, r)

    if (node.left) {
      dfs(node.left, r + 1, 0)
    }

     if (node.right) {
      dfs(node.right, 0, l + 1)
    }
  }

  dfs(root, 0, 0)
  
  return res
};

236. 二叉树的最近公共祖先

思路

递归遍历二叉树，遇到节点 p 或 q 时返回。从底到顶回溯，当节点 p, q 在 root 两侧时，向上返回 root。

代码

js 复制代码

var lowestCommonAncestor = function(root, p, q) {
  if (root === null || root === p || root === q) {
    return root
  }
  let left = lowestCommonAncestor(root.left, p, q)
  let right = lowestCommonAncestor(root.right, p, q)
  if (left === null) return right
  if (right === null) return left

  return root
};

199. 二叉树的右视图

思路

深度优先遍历，每次先遍历右节点，当结果层数 res.length 等于深度 depth 时，🧵1结果数组添加节点值。

代码

js 复制代码

var rightSideView = function(root) {
  const res = []
 
  const dfs = (node, depth) => {
    if (node === null) {
      return
    }

    if (depth === res.length) {
      res.push(node.val)
    }

    depth++
    dfs(node.right, depth)
    dfs(node.left, depth)
  }

  dfs(root, 0)

  return res
};

本文完，感谢阅读 🌹