LeetCode 250：同值子树的个数

深度优先搜索：直观上感觉是后序，但并不是严格的后序遍历

 Python实现：注意短路效应带来的bug，比较隐蔽

class Solution:
    def countUnivalSubtrees(self, root: TreeNode) -> int:
        if root == None:
            return 0
        self.counts = 0
        self.is_uni(root)
        return self.counts

    def is_uni(self, node: TreeNode) -> bool:
        ## 叶子节点
        if node.left is None and node.right is None:
            self.counts += 1
            return True
        
        ## 非叶子节点,递归后序遍历
        flag = True #flag引入很关键，我就卡在了这里，把if写的很长，不知道如何处理
        if node.left is not None:
            #flag = flag and self.is_uni(node.left) and node.left.val==node.val #隐蔽的Bug:flag放在前面,由于 && 运算的短路效应，一旦flag不是true,之后的递归均不会进行了...
            flag = self.is_uni(node.left) and node.left.val == node.val and flag
        if node.right is not None:
            flag = self.is_uni(node.right) and node.right.val==node.val and flag
        
        if flag is True:
            self.counts += 1
        
        return flag

C++实现，和Python思路一样。 

class Solution {
public:
    int countUnivalSubtrees(TreeNode* root) {
        if(!root) return 0;
        is_uni(root);
        return count;
    }

private:
    int count = 0;
    bool is_uni(TreeNode* node) {
        if(!node->left && !node->right) {
            count += 1;
            return true;
        }

        bool flag = true;
        if(node->left != nullptr) {
            flag = is_uni(node->left) && node->left->val == node->val && flag;
        }
        if(node->right != nullptr) {
            flag = is_uni(node->right) && node->right->val == node->val && flag;
        }
        if(flag) count += 1;
        return flag;
    }
};