LeetCode 二叉树的最近公共祖先

给定一个二叉树, 找到该树中两个指定节点的最近公共祖先。

百度百科中最近公共祖先的定义为：“对于有根树 T 的两个结点 p、q，最近公共祖先表示为一个结点 x，满足 x 是 p、q 的祖先且 x 的深度尽可能大（一个节点也可以是它自己的祖先）。”

例如，给定如下二叉树: root = [3,5,1,6,2,0,8,null,null,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 为不同节点且均存在于给定的二叉树中。

请先翻阅 LeetCode 二叉搜索树的最近公共祖先
上一道题是判断二叉搜索树中两个节点的最近公共祖先，是利用二叉搜索树的中序遍历严格递增的特性。但是此题是一个一般的二叉树，并无此特性，只能一般处理。
但是还是根据p、q的位置进行判断，分别处理

如果p或q的val与当前root相同，那么公共祖先必定是当前root。
如果p、q分别处于当前root的两端，那么公共祖先必定是当前root
否则选择p、q在root的同一端，更新root为p、q所在的端，继续搜索。

非递归版

/**
 * 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) {
		bool pFlag, qFlag;
		while (root != NULL) {
			if (root->val == p->val || root->val == q->val) {
				return root;
			}
			pFlag = isExist(root->left, p);//判断p是否在当前左子树
			qFlag = isExist(root->right, q);//判断q是否在当前右子树
            //如果pFlag、qFlag同号，说明p、q各在根节点的两端
			if (pFlag == qFlag) {
				return root;
			}
			root = (pFlag ? root->left : root->right);//更新root为p、q所在的共同端
		}
		return root;
	}
	//用于判断nodePtr是否在root这棵树中
	bool isExist(TreeNode* root, TreeNode* nodePtr) {
		if (root == NULL) {
			return false;
		}
		//判断根节点                             判断左子树是否存在           判断右子树是否存在
		return root->val == nodePtr->val || isExist(root->left, nodePtr) || isExist(root->right, nodePtr);
	}
};

/**
 * 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) {
        if (root == NULL || root->val == p->val || root->val == q->val){
            return root;
        }
        bool pFlag = isExist(root->left, p);//判断p是否在左子树
        bool qFlag = isExist(root->right, q);//判断q是否在右子树
        if (pFlag == qFlag){//如果pFlag、qFlag同号，说明p、q各在根节点的两端
            return root;
        }
        //下面处理p、q在同一端的情况
        root = (pFlag ? root->left:root->right);
        return lowestCommonAncestor(root, p, q);
    }
    //用于判断nodePtr是否在root这棵树中
    bool isExist(TreeNode* root, TreeNode* nodePtr){
        if (root == NULL){
            return false;
        }
        //判断根节点                             判断左子树是否存在           判断右子树是否存在
        return root->val == nodePtr->val || isExist(root->left, nodePtr) || isExist(root->right, nodePtr);
    }
};

下面是示例

/**
 * 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) {
		 if (root == NULL || root == p || root == q) return root;
		 //如果没有匹配到节点 就会返回null
		 //但凡匹配到任何一个节点，都不会返回null;
		 TreeNode* left = lowestCommonAncestor(root->left, p, q);
		 TreeNode* right = lowestCommonAncestor(root->right, p, q);
		 //如果左边，右边都找到了节点，那就是最近的公共祖先
		 if (left && right)
			 return root;
		 return left == NULL ? right : left;
	 }
 };