完全二叉树的节点个数+二叉树的公共祖先

leecode222：给你一棵 完全二叉树 的根节点 root ，求出该树的节点个数。

完全二叉树（complete binary tree） 的定义如下：在完全二叉树中，除了最底层节点可能没填满外，其余每层节点数都达到最大值，并且最下面一层的节点都集中在该层最左边的若干位置。若最底层为第 h 层，则该层包含 1~ 2h 个节点。

补充：满二叉树（perfect binary tree）：每一层都是满的，每个节点都有两个孩子，最后一层没有孩子，任意左右两个子树节点数相同，像一个稳定的三角形；

          full binary tree：每个节点都有两个孩子，但左右子树的的高度（深度）不同，左右子树的节点数不同；

C++ 时间复杂度为：

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    int countNodes(TreeNode* root) {
        TreeNode* l=root;
        TreeNode* r=root;
        int hl=0, hr=0;
        while(l){
            l = l->left;
            hl++;
        }
        while(r){
            r = r->right;
            hr++;
        }
        if(hl == hr) return (1<<hl) - 1;
        return 1 + countNodes(root->left) + countNodes(root->right); 
    }
};

C++ 递归 耗时较多：

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    int countNodes(TreeNode* root) {
        if(!root) return 0;
        return countNodes(root->left) + countNodes(root->right) + 1;
    }
};

 

Python：

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def countNodes(self, root: TreeNode) -> int:
        l = r = root
        TreeNode(l)
        TreeNode(r)
        hl, hr = 0, 0
        while l:
            l = l.left
            hl +=1
        while r:
            r = r.right
            hr +=1
        if hl == hr:
            return int(pow(2, hl)) - 1
        return 1 + self.countNodes(root.left) + self.countNodes(root.right)

Leecode 236：二叉树的公共祖先：

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

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

C++：

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

Python：

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution:
    def lowestCommonAncestor(self, root: 'TreeNode', p: 'TreeNode', q: 'TreeNode') -> 'TreeNode':
        if not root: return None
        if root==p or root==q: return root
        left = self.lowestCommonAncestor(root.left, p, q)
        right = self.lowestCommonAncestor(root.right, p, q)
        if not left and not right: return None
        if not left: return right
        if not right: return left
        return root