力扣日常练习

二叉树的最大深度(简单)

给定一个二叉树，找出其最大深度。

二叉树的深度为根节点到最远叶子节点的最长路径上的节点数。

解题：

采用递归的方式去求解二叉树的最大深度。

/**
 * 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:
    int maxDepth(TreeNode* root) {
        if (root == nullptr)
            return 0;
        int leftmax = maxDepth(root->left);
        int rightmax = maxDepth(root->right);
        return max(leftmax, rightmax) + 1;
    }
};

平衡二叉树(简单) 

给定一个二叉树，判断它是否是高度平衡的二叉树。

本题中，一棵高度平衡二叉树定义为：

一个二叉树每个节点 的左右两个子树的高度差的绝对值不超过1。

解题：

同样采用递归的思想，根据平衡二叉数的定义，首先判断左右子树的最大深度差是否满足绝对值小于等于1，紧接着判断左右子树的平衡性，进而推理出递归函数的编写：

/**
 * 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:
    bool isBalanced(TreeNode* root) {
        if(root == nullptr)
            return true;
        int leftmax = maxDepth(root->left);
        int rightmax = maxDepth(root->right);
        if (abs(leftmax - rightmax) > 1)
            return false;
        else
            return isBalanced(root->left) && isBalanced(root->right);
    }
    int maxDepth(TreeNode* root) {
        if (root == nullptr)
            return 0;
        int leftmax = maxDepth(root->left);
        int rightmax = maxDepth(root->right);
        return max(leftmax, rightmax) + 1;
    }
};

二叉树的最小深度(简单)

给定一个二叉树，找出其最小深度。

最小深度是从根节点到最近叶子节点的最短路径上的节点数量。

说明: 叶子节点是指没有子节点的节点。

解题：

这道题跟刚才那道二叉树的最大深度题十分相似，但是又有些许不同之处，同样的我们采用递归的方式来求解，我们知道二叉树的最小深度是指从根节点到最近叶子节点的最短路径长度，由此我们可以推导出：min(root) = min(min(left) + min(right)) + 1，但是需要注意的一点是，当我们的左子树单独为空或者右子树单独为空时，此时该子树便不存在叶子节点了，因此我们需要不考虑这棵子树的情况，接下来给出代码实现：

/**
 * 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:
    int minDepth(TreeNode* root) {
        if (root == nullptr)
            return 0;
        else if (root->left == nullptr && root->right == nullptr)
            return 1;
        else if (root->left == nullptr)
            return minDepth(root->right) + 1;
        else if (root->right == nullptr)
            return minDepth(root->left) + 1;
        else
            return min(minDepth(root->left), minDepth(root->right)) + 1;
    }
};

路径总和(简单)

给定一个二叉树和一个目标和，判断该树中是否存在根节点到叶子节点的路径，这条路径上所有节点值相加等于目标和。

说明: 叶子节点是指没有子节点的节点。

解题：

采用递归的方式，首先判断当前节点是否为叶子节点，若为叶子节点，则判断当前目标和减去叶子节点value是否等于0，若不是叶子节点，则对左右节点递归调用该函数，并同时修改目标和为(sum-root->value)。下面给出具体代码实现：

/**
 * 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:
    bool hasPathSum(TreeNode* root, int sum) {
        if (root == nullptr)
            return false;
        sum -= root->val;
        if (root->left == nullptr && root->right == nullptr)
            return sum == 0;
        return hasPathSum(root->left, sum) || hasPathSum(root->right, sum);
    }
};

杨辉三角(简单)

给定一个非负整数 numRows，生成杨辉三角的前 numRows 行。

在杨辉三角中，每个数是它左上方和右上方的数的和。

解题：

根据杨辉三角的性质，非常容易的写出对应实现：

class Solution {
public:
    vector> generate(int numRows) {
        vector> ans;
        if (numRows == 0)
            return ans;
        vector ivec = {1};
        ans.push_back(ivec);
        if (numRows == 1)
            return ans;
        for (int i = 0; i < numRows - 1; ++i)
        {
            vector level = {1};
            for(int j = 0; j < ans[i].size() - 1; ++j)
                level.push_back(ans[i][j] + ans[i][j+1]);
            level.push_back(1);
            ans.push_back(level);
        }
        return ans;
    }
};

杨辉三角2(简单)

给定一个非负索引 k，其中 k ≤ 33，返回杨辉三角的第 k 行。

解题：

跟上一题类似，不同的是这次只需返回指定行即可：

class Solution {
public:
    vector getRow(int rowIndex) {
        vector first = {1};
        for (int i = 0; i < rowIndex; ++i)
        {
            vector leval = {1};
            for(int j = 0; j < first.size()- 1; ++j)
                leval.push_back(first[j] + first[j+1]);
            leval.push_back(1);
            first.swap(leval);
        }
        return first;
    }
};