练习题（2024/5/5）

1左叶子之和

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

示例 1：

输入: root = [3,9,20,null,null,15,7] 
输出: 24 
解释: 在这个二叉树中，有两个左叶子，分别是 9 和 15，所以返回 24

示例 2:

输入: root = [1]
输出: 0

提示:

• 节点数在 [1, 1000] 范围内
• -1000 <= Node.val <= 1000

思路：采用递归的方法，先计算左子树中左叶子节点的和，然后判断左子树是否为叶子节点，如果是则将该节点的值加入左叶子节点的和中。接着递归计算右子树中左叶子节点的和，最后将左子树和右子树的左叶子节点和相加得到最终结果。

代码：

class Solution {
public:
    int sumOfLeftLeaves(TreeNode* root) {
        if(root ==nullptr) return 0; // 如果根节点为空，返回0
        int leftvalues=sumOfLeftLeaves(root -> left); // 递归计算左子树中左叶子节点的和
        if(root->left !=nullptr && root->left->left == nullptr && root->left->right==nullptr){
            leftvalues=root->left->val; // 如果左子树是叶子节点，则将该节点的值加入左叶子节点的和中
        }
        int rightvalues=sumOfLeftLeaves(root->right); // 递归计算右子树中左叶子节点的和
        int sum=leftvalues+rightvalues; // 左叶子节点的和加上右子树左叶子节点的和就是最终结果
        return sum; // 返回最终结果
    }
};

2找树左下角的值

给定一个二叉树的 根节点 root，请找出该二叉树的 最底层 最左边节点的值。

假设二叉树中至少有一个节点。

示例 1:

输入: root = [2,1,3]
输出: 1

示例 2:

输入: [1,2,3,4,null,5,6,null,null,7]
输出: 7

提示:

• 二叉树的节点个数的范围是 [1,104]
• -231 <= Node.val <= 231 - 1

思路：

层序遍历的方法，即利用队列按层级遍历节点。首先将根节点加入队列，然后循环处理队列中的节点，每次处理完一层后更新结果值。遍历过程中将每个节点的左孩子和右孩子节点加入队列。最终返回最底层最左侧节点的值作为结果。

代码：

class Solution {
public:
    int findBottomLeftValue(TreeNode* root) {
        queue<TreeNode*> que; // 创建一个队列用于层序遍历
        if(root != nullptr) que.push(root); // 如果根节点不为空，则将根节点加入队列
        int result=0; // 用于保存最后的结果
        while(!que.empty()){ // 当队列不为空时继续循环
            int size=que.size(); // 获取当前层的节点数
            for(int i=0;i<size;i++){ // 遍历当前层的节点
                TreeNode* node=que.front(); // 获取队头节点
                que.pop(); // 出队
                if(i==0) result=node->val; // 如果是当前层的第一个节点，则更新结果
                if(node->left) que.push(node->left); // 将左孩子节点加入队列
                if(node->right) que.push(node->right); // 将右孩子节点加入队列
            }
        }
        return result; // 返回最后的结果
    }
};

3路径总和

给你二叉树的根节点 root 和一个表示目标和的整数 targetSum 。判断该树中是否存在 根节点到叶子节点 的路径，这条路径上所有节点值相加等于目标和 targetSum 。如果存在，返回 true ；否则，返回 false 。

叶子节点 是指没有子节点的节点。

示例 1：

输入：root = [5,4,8,11,null,13,4,7,2,null,null,null,1], targetSum = 22
输出：true
解释：等于目标和的根节点到叶节点路径如上图所示。

示例 2：

输入：root = [1,2,3], targetSum = 5
输出：false
解释：树中存在两条根节点到叶子节点的路径：
(1 --> 2): 和为 3
(1 --> 3): 和为 4
不存在 sum = 5 的根节点到叶子节点的路径。

示例 3：

输入：root = [], targetSum = 0
输出：false
解释：由于树是空的，所以不存在根节点到叶子节点的路径。

思路：

利用递归遍历二叉树的每个节点，并在遍历过程中不断更新当前的路径和。具体步骤如下：

1. 若当前节点为空，则直接返回false。
2. 在遇到叶子节点时，即当前节点的左右子节点均为空，并且当前路径和等于0，则返回true；若不满足条件，则返回false。
3. 对当前节点的左子节点和右子节点进行递归处理：首先将当前节点值从路径和中减去，判断递归左子节点和右子节点的返回值，若其中一条路径存在符合条件的路径则返回true。
4. 如果所有路径都没有符合条件的路径，则返回false。

代码：

class Solution {
private:
    bool traversal(TreeNode* cur, int count) {
        // 遇到叶子节点，并且计数为0时返回true
        if (cur->left == nullptr && cur->right == nullptr && count == 0) return true;
        // 遇到叶子节点直接返回false
        if (cur->left == nullptr && cur->right == nullptr) return false;

        if (cur->left) { // 处理左子节点
            count -= cur->left->val; // 处理节点值
            if (traversal(cur->left, count)) return true; // 递归至左子节点，继续判断
            count += cur->left->val; // 恢复处理节点值，准备处理其他分支
        }
        if (cur->right) { // 处理右子节点
            count -= cur->right->val; // 处理节点值
            if (traversal(cur->right, count)) return true; // 递归至右子节点，继续判断
            count += cur->right->val; // 恢复处理节点值，准备处理其他分支
        }
        return false;
    }

public:
    bool hasPathSum(TreeNode* root, int sum) {
        if (root == nullptr) return false;
        return traversal(root, sum - root->val); // 调用递归函数进行遍历判断
    }
};

4股票的资本损益

Stocks 表：

+---------------+---------+
| Column Name   | Type    |
+---------------+---------+
| stock_name    | varchar |
| operation     | enum    |
| operation_day | int     |
| price         | int     |
+---------------+---------+
(stock_name, day) 是这张表的主键(具有唯一值的列的组合)
operation 列使用的是一种枚举类型，包括：('Sell','Buy')
此表的每一行代表了名为 stock_name 的某支股票在 operation_day 这一天的操作价格。
此表可以保证，股票的每个“卖出”操作在前一天都有相应的“买入”操作。并且，股票的每个“买入”操作在即将到来的一天都有相应的“卖出”操作。

编写解决方案报告每只股票的 资本损益。

股票的 资本利得/损失是指一次或多次买卖该股票后的总收益或损失。

以 任意顺序 返回结果表。

结果格式如下所示。

示例 1：

输入：
Stocks 表:
+---------------+-----------+---------------+--------+
| stock_name    | operation | operation_day | price  |
+---------------+-----------+---------------+--------+
| Leetcode      | Buy       | 1             | 1000   |
| Corona Masks  | Buy       | 2             | 10     |
| Leetcode      | Sell      | 5             | 9000   |
| Handbags      | Buy       | 17            | 30000  |
| Corona Masks  | Sell      | 3             | 1010   |
| Corona Masks  | Buy       | 4             | 1000   |
| Corona Masks  | Sell      | 5             | 500    |
| Corona Masks  | Buy       | 6             | 1000   |
| Handbags      | Sell      | 29            | 7000   |
| Corona Masks  | Sell      | 10            | 10000  |
+---------------+-----------+---------------+--------+
输出：
+---------------+-------------------+
| stock_name    | capital_gain_loss |
+---------------+-------------------+
| Corona Masks  | 9500              |
| Leetcode      | 8000              |
| Handbags      | -23000            |
+---------------+-------------------+
解释：
Leetcode 股票在第一天以1000美元的价格买入，在第五天以9000美元的价格卖出。资本收益=9000-1000=8000美元。
Handbags 股票在第17天以30000美元的价格买入，在第29天以7000美元的价格卖出。资本损失=7000-30000=-23000美元。
Corona Masks 股票在第1天以10美元的价格买入，在第3天以1010美元的价格卖出。在第4天以1000美元的价格再次购买，在第5天以500美元的价格出售。最后，它在第6天以1000美元的价格被买走，在第10天以10000美元的价格被卖掉。资本损益是每次（’Buy'->'Sell'）操作资本收益或损失的和=（1010-10）+（500-1000）+（10000-1000）=1000-500+9000=9500美元。

思路：

通过SQL语句中的case表达式来根据不同的operation值计算price或-price，并将结果按照股票名称进行分组求和，得到每个股票的资本收益损失。

case语句的基本语法如下:

CASE
    WHEN condition1 THEN result1
    WHEN condition2 THEN result2
    ...
    ELSE result_n
END

其中，case后面可以跟随多个when条件和对应的结果，最后可以有一个else的默认结果。整个case语句返回第一个满足条件的结果，如果没有满足条件的结果，则返回else中指定的默认结果。

代码：

select  stock_name  ,
sum(
   case operation
    when 'Sell' then price
    else -price
end )as capital_gain_loss
from Stocks
group by stock_name