代码随想录算法 Day15 | Ch6 二叉树(三)● 110.平衡二叉树 ● 257. 二叉树的所有路径 ●404. 左叶子之和 ● 222.完全二叉树的节点个数

引言

        今日习题优先掌握递归。

一、平衡二叉树

        1.题目：给定一个二叉树，判断它是否是 平衡二叉树。

 

        2.思路：

        3.注意：

        （1）平衡二叉树：左节点和右节点深度差不超过1。

        （2）在 bool 类型函数中，返回值分为 0 和 非0 ，返回 -1 会被认为是 true。

        4.代码：

/**
 * 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 getHeight(TreeNode* node)
    {
        if(node == NULL)
            return 0;

        int leftHeight = getHeight(node->left);
        if(leftHeight == -1) return -1;
        int rightHeight = getHeight(node->right);
        if(rightHeight == -1) return -1;

        int heightAbs = abs(leftHeight - rightHeight);
        if(heightAbs > 1) return -1;
        return ( 1 + max(leftHeight, rightHeight) );
    }

    bool isBalanced(TreeNode* root) {
        return getHeight(root)==-1? false : true;
    }
};

二、二叉树的所有路径

        1.题目：给你一个二叉树的根节点 root ，按 任意顺序 ，返回所有从根节点到叶子节点的路径。叶子节点 是指没有子节点的节点。

        2.思路：递归，前序遍历，回溯思想

        3.注意：

        （1）递归的终止条件是递归到叶子节点

        （2）vector 中把元素 a 变为字符串使用 to_string(a)

        （3）字符串 s1 后面添加字符串 s2 时使用双引号 " "，使用单引号 's2' 时只会添加s2的最后一个字符，例如 '->' 会只添加 > 字符。

        4.代码：

/**
 * 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:
    void getPath(TreeNode* node,vector<int> &path, vector<string> &res)
    {
        path.push_back(node->val);

        if(node->left == NULL && node->right == NULL)
        {
            string sPath;
            for(int i=0; i< path.size()-1; i++)
            {
                sPath += to_string(path[i]);
                sPath += "->";
            }

            sPath += to_string(path[path.size()-1]);
            res.push_back(sPath);
        }

        if(node->left)
        {
            getPath(node->left, path, res);
            path.pop_back();
        }

        if(node->right)
        {
            getPath(node->right, path, res);
            path.pop_back();
        }
    }


    vector<string> binaryTreePaths(TreeNode* root) {
        vector<int> path;
        vector<string> result;

        if(root==NULL) return result;
        getPath(root, path, result);

        return result;

    }
};

三、左叶子之和

        1.题目：给定二叉树的根节点 root ，返回所有左叶子之和。

        2.思路：

        3.注意：

        （1）左叶子节点不是左侧节点，既满足是叶子节点，也满足是父节点的左侧节点。

        4.代码：

/**
 * 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 traversal(TreeNode* node, vector<int> &leftVal, bool isLeft)
    {
        int sum=0;

        if( node->left == NULL && node->right == NULL && isLeft)
        {
           leftVal.push_back(node->val);
        }

        if( node->left != NULL )    // 左
        {
           traversal(node->left, leftVal, 1);
        }

        if(node->right != NULL)     // 右
            traversal(node->right, leftVal, 0);

        for(int i=0; i<leftVal.size(); i++)
        {
            sum += leftVal[i];
        }    
        return sum;
    }

    int sumOfLeftLeaves(TreeNode* root) {
        vector<int> leftArray;
        int sum=0;

        if(!root) return sum;

        sum = traversal(root, leftArray, 0);

        return sum;
    }
};

五、完全二叉树的节点个数

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

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

2.思路：根据完全二叉树的性质使用二分查找

3.注意：

4.代码：

方法一：二分查找

class Solution {
public:
    // 求二叉树的深度
    int countLevels(TreeNode* root) {
    	int levels = 0;
    	while (root) {
    	    root = root->left; levels += 1;
        }
        return levels;
    }

    /*
    * 功能： 判断最后一层第index个索引是否存在
    * root： 二叉树根节点
    * index：判断最后一层索引为index的节点是否存在, 索引范围是[1, 2^depth]
    * depth：倒数第二层的深度, 这是因为满二叉树最后一层的节点数等于 2^depth
    */
    bool is_exist(TreeNode* root, int index, int depth) {
        TreeNode* node = root;
        while (depth) {
            // 最后一层分界线
            int mid = ((1 << depth) >> 1);
            if (index > mid) {
                // 如果在右子树，需要更新索引值
                index -= mid;
                node = node->right;
            }
            else {
                node = node->left;
            }
            depth -= 1;
        }
        return node != nullptr;
    }

    int countNodes(TreeNode* root) {
        // 3. 二分查找
        if (root == nullptr) return 0;
        // 二叉树深度
        int depth = countLevels(root);
        // 倒数第二层深度
        int depth_prev = depth - 1;

        int start = 1, end = (1 << depth_prev), mid = 0;
        while (start <= end) {
            mid = start + ((end - start) >> 1);
            if (is_exist(root, mid, depth_prev)) start = mid + 1;
            else end = mid - 1;
        }
        // start - 1为最后一层节点数
        int ret = (1 << depth_prev) - 1 + start - 1;
        return ret;
    }
};

方法二：暴力递归

/**
 * 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) {
        int sum=0;

        if(!root) return 0;
        
        sum++;

        sum += countNodes(root->left);
        sum += countNodes(root->right);

        return sum;

    }
};