235. Lowest Common Ancestor of a Binary Search Tree 236. Lowest Common Ancestor of a Binary Tree

235. Lowest Common Ancestor of a Binary Search Tree

求最近的公共祖先。（二叉搜索树）
Given a binary search tree (BST), find the lowest common ancestor (LCA) of two given nodes in the BST.

According to the definition of LCA on Wikipedia: “The lowest common ancestor is defined between two nodes p and q as the lowest node in T that has both p and q as descendants (where we allow a node to be a descendant of itself).”

Given binary search tree: root = [6,2,8,0,4,7,9,null,null,3,5]

Example 1:

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

Input: root = [6,2,8,0,4,7,9,null,null,3,5], p = 2, q = 4
Output: 2
Explanation: The LCA of nodes 2 and 4 is 2, since a node can be a descendant of itself according to the LCA definition.

思路
pq的特点就是，一个一定大于root值，一个一定小于root值

如果pq都小于root的值，那么去左子树继续找
如果p在左，q在右，那么结果就是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:
    TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {
        // 如果pq都小于root的值，那么去左子树继续找
        if(root->val > p->val && root->val > q->val) {
            return lowestCommonAncestor(root->left, p, q);
        } else if (root->val < p->val && root->val < q->val) {
             return lowestCommonAncestor(root->right, p, q);
        } else {
            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:
    TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {
        // 非递归
        while(root) {
            if(root->val > p->val && root->val > q->val) {
                root = root->left;
            } else if (root->val < p->val && root->val < q->val) {
                root = root->right;
            } else {
            	// 找到一个节点，值在pq之间，
                return root;
            }
        }
        return root;
    }
};

236. Lowest Common Ancestor of a Binary Tree

求最近的公共祖先。（普通的二叉树）
Given a binary tree, find the lowest common ancestor (LCA) of two given nodes in the tree.

According to the definition of LCA on Wikipedia: “The lowest common ancestor is defined between two nodes p and q as the lowest node in T that has both p and q as descendants (where we allow a node to be a descendant of itself).”

Given the following binary tree: root = [3,5,1,6,2,0,8,null,null,7,4]

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.

---

思路1

1. 方法一：p,q 从下往上找路径，找最早重合的节点，（需要有父亲节点的指针） O(N)
2. 方法二：从上往下找pq,找到路径1，2，最后重合的点就是他们的公共祖先
   O(N)

思路2
Recursion

-findPorQ(root, p, q) // 在root为跟的子树中找p或q,找到则返回pq
if root == p or root == q
return root
else
findPorQ(root->left, p,q)
findPorQ(root->right, p,q)

停止递归条件1：假设pq其中一个为根节点，那么答案肯定是这个root了。
停止递归条件2：如果pq一个在左子树一个在右子树，那么答案也是这个root了。
继续递归：如果pq都在左子树，那么答案肯定也是左子树中的，继续往左子树中查询。
右同左

/**
 * 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:
	// lowestCommonAncestor = findPorQ
    TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {
        if(root == nullptr || root == p || root == q) {
            return root;
        } 
        
        TreeNode *left = lowestCommonAncestor(root->left, p, q);
        TreeNode *right = lowestCommonAncestor(root->right, p, q);
        
        if(left == nullptr) {
            return right;
        } else if(right == nullptr) {
            return left;
        } else {
            return root;
        }
    }
};