【一棵树】236. Lowest Common Ancestor of a Binary Tree

问题：

给出一颗二叉树，两个节点p和q，求出这两节点的最近公共父节点（LCA）。

Example 1:
Input: root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 1
Output: 3
Explanation: The LCA of nodes 5 and 1 is 3.

Example 2:
Input: root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 4
Output: 5
Explanation: The LCA of nodes 5 and 4 is 5, since a node can be a descendant of itself according to the LCA definition.
 
Note:
All of the nodes' values will be unique.
p and q are different and both values will exist in the binary tree.

解法：Binary Tree（二叉树）

递归

1. 函数定义：

    -> 找p和q的最近公共父节点

TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q)

• 参数：
  • 当前node：root
  • 寻找目标节点：p，q
• 返回值：
  • 未找到：
    • case_1: p和q都没找到(!p and !q)：返回 null
    • case_2: (2-1)找到其中一个(p or q)：返回 找到的对象 !p?q:p
  • 找到：case_3:
  • (3-1)之前的节点处已经找到：返回 上一次调用递归函数的结果 left or right
  • (3-2)刚好，当前节点处找到：返回 root

2. 状态：（每次调用函数的变化的参数）root

3. 选择：（得到递归结果后的处理）

• left==null && right==null
  • -> return null
• left!=null && right!=null
  • -> return root
• left!=null || right!=null
  • left!=null
    • -> return left
  • right!=null
    • -> return right

4. base case:

• root==null
  • -> return null
• root==p || root==q
  • -> return root

代码参考：

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    //DEF of fun: From root, return the LCA node of p and q.
    //Mutative Param of fun: root
    //Opt:
    //case_1: neither of them, under root:
    //        -> return null
    //case_2: one of them, under root:
    //        -> return itself (2-1)
    //case_3: both of them, under root:
    //            both of them, under left(right) tree:
    //                -> return the pre-result  (3-1)
    //            one under left tree, the other one under right tree:
    //                -> return root(cur-node)  (3-2)
    //base case:
    //root==null, but can't find p or q:
    //       -> return null (case_1)
    //root==p or q:
    //       -> return root (case_2)
    TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {
        //base
        if(!root) return nullptr;
        if(root == p || root == q) return root;
        //recursion
        TreeNode* left = lowestCommonAncestor(root->left, p, q);
        TreeNode* right = lowestCommonAncestor(root->right, p, q);
        //opt
        //case_1:
        if(!left && !right) return nullptr;
        //case_3:(3-2)
        if(left && right) return root;
        //case_2:(2-1) && case_3:(3-1)
        //left or right (one of them) is null
        return (!left)?right:left;
    }
};