二叉树查找公共祖先

找出二叉树中某两个节点的第一个共同祖先，不得将其他的节点存储在另外的数据结构中。

例如，给定如下二叉树: root = [3,5,1,6,2,0,8,null,null,7,4]，相应的树型结构为：

    3
   / \
  5   1
 / \ / \
6  2 0  8
  / \
 7   4

示例 1:
输入: root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 1
输出: 3
解释: 节点 5 和节点 1 的最近公共祖先是节点 3。

示例 2:
输入: root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 4
输出: 5
解释: 节点 5 和节点 4 的最近公共祖先是节点 5。因为根据定义最近公共祖先节点可以为节点本身。

说明:

• 所有节点的值都是唯一的
• p、q 为不同节点且均存在于给定的二叉树中。

// 二叉树数据结构:
function TreeNode(val) {
  this.val = val;
  this.left = this.right = null;
}
// your code here:

235--二叉搜索树的最近公共祖先

    6
   / \
  2   8
 / \ / \
0  4 7  9
  / \
 3   5

方法1

思路：找到p的所有祖先的集合treeP和找到q的所有祖先的集合treeQ(包含自身)，然后找到treeP和treeQ最近的祖先节点

/**
 * @param {TreeNode} root
 * @param {TreeNode} p
 * @param {TreeNode} q
 * @return {TreeNode}
 */
var lowestCommonAncestor = function(root, p, q) {
  const getTreeParent = (tree, target) => {
    const map = []
    let node = tree
    while (node && node.val !== target.val) {
      map.push(node);
      if (node.val > target.val) {
        node = node.left
      } else {
        node = node.right
      }
    }
    map.push(target)
    return map
  }
  const treeP = getTreeParent(root, p)
  const treeQ = getTreeParent(root, q)
  let ancestor = null
  for (let i = 0; i < treeP.length && i < treeQ.length; i++) {
    if (treeP[i] == treeQ[i]) {
      ancestor = treeP[i]
    } else {
      break;
    }
  }
  return ancestor
};

方法2

思路：使用递归，根据搜索二叉树特性：搜索二叉树的节点的左边都是小于节点的值，节点的右边都是大于节点的值，如果p和q都小于root，说明p和q都在root的左边，然后在root的左节点查找，同理右节点。如果正好q和q在root的左右，那么root就是最近祖先。

/**
 * @param {TreeNode} root
 * @param {TreeNode} p
 * @param {TreeNode} q
 * @return {TreeNode}
 */
var lowestCommonAncestor = function(root, p, q) {
  if (root.val > p.val && root.val > q.val) return lowestCommonAncestor(root.left, p, q)
  if (root.val < p.val && root.val < q.val) return lowestCommonAncestor(root.right, p, q)
  return root
};

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

如果p和q在树的2侧，说明当前节点就是最近公众祖先

/**
 * @param {TreeNode} root
 * @param {TreeNode} p
 * @param {TreeNode} q
 * @return {TreeNode}
 */
var lowestCommonAncestor = function(root, p, q) {
  if (root === null || root.val === p.val || root.val === q.val) return root
  let left = lowestCommonAncestor(root.left, p, q)
  let right = lowestCommonAncestor(root.right, p, q)
  if (left && right) return root
  return left ? left : right
};