二叉树的深度以及平衡二叉树的判断

// 面试题55（一）：二叉树的深度
    // 题目：输入一棵二叉树的根结点，求该树的深度。从根结点到叶结点依次经过的
    // 结点（含根、叶结点）形成树的一条路径，最长路径的长度为树的深度。
    static int depth_r(const std::shared_ptr<node_bt<int>>& root)
    {
        if(root == nullptr)
        {
            return 0;
        }

        int left = depth_r(root->left);
        int right = depth_r(root->right);

        return (left > right) ? (left + 1) : (right + 1);
    }

    static uint32_t depth(const std::shared_ptr<node_bt<int>>& root)
    {
        if(root == nullptr)
        {
            return 0;
        }

        std::queue<std::shared_ptr<node_bt<int>>> que;
        que.push(root);
        int level_num = 0;
        int temp_num = 1;
        uint32_t depth=1;

        while(!que.empty())
        {
            auto node = que.front();
            que.pop();

            if(node->left != nullptr)
            {
                que.push(node->left);
                ++level_num;
            }
            if(node->right != nullptr)
            {
                que.push(node->right);
                ++level_num;
            }

            --temp_num;
            if(temp_num == 0)
            {
                temp_num = level_num;
                level_num = 0;
                depth++;
            }
        }

        return depth;
    }

    // 面试题55（二）：平衡二叉树
    // 题目：输入一棵二叉树的根结点，判断该树是不是平衡二叉树。如果某二叉树中
    // 任意结点的左右子树的深度相差不超过1，那么它就是一棵平衡二叉树。
    // ====================方法1====================
    static bool is_balance_r(const std::shared_ptr<node_bt<int>>& root)
    {
        if(root == nullptr)
        {
            return true;
        }

        int left = depth(root->left);
        int right = depth(root->right);
        int diff = left - right;
        if(diff > 1 || diff < -1)
        {
            return false;
        }

        return is_balance_r(root->left) && is_balance_r(root->right);
    }

    // ====================方法2====================
    static bool is_balance_r2(const std::shared_ptr<node_bt<int>>& root)
    {
        int depth = 0;
        return _is_balance(root, depth);
    }

    static bool _is_balance(const std::shared_ptr<node_bt<int>>& root, int& depth)
    {
        if(root == nullptr)
        {
            depth = 0;
            return true;
        }

        int left, right;
        if(_is_balance(root->left, left) && _is_balance(root->right, right))
        {
            int diff = left - right;
            if(diff <= 1 && diff >= -1)
            {
                depth = 1 + (left > right ? left : right);
                return true;
            }
        }

        return false;
    }