【LeetCode】力扣刷题之路 (20240219~20240223)

题目(20240219~20240223)

94.二叉树的中序遍历

给定一个二叉树的根节点 root ，返回它的中序遍历。

示例 1：

输入：root = [1,null,2,3]
输出：[1,3,2]

示例 2：

输入：root = []
输出：[]

示例 3：

输入：root = [1]
输出：[1]

知识点回顾

二叉树（Binary tree）：是指树中节点的度不大于2的有序树，它是一种最简单且最重要的树。
中序遍历（LNR）:是二叉树遍历的一种方法，也被称为中根遍历或中序周游。遵循“左->根->右”的顺序。也可以形象地描述为：如果二叉树为空，则执行空操作；否则，先进行左子树的遍历，接着访问根结点，最后进行右子树的遍历。

代码

方法1：递归

from typing import Optional, List


# 定义二叉树节点
class TreeNode:
    def __init__(self, val=0, left=None, right=None):
        self.val = val
        self.left = left
        self.right = right


# 递归
class Solution:
    # 中序遍历方法
    def inorderTraversal(self, root: Optional[TreeNode]) -> List[int]:
        # 空树
        if not root:
            return []
        left = self.inorderTraversal(root.left)
        right = self.inorderTraversal(root.right)
        res = left + [root.val] + right
        return res


if __name__ == "__main__":
    # 构造测试二叉树 示例1
    root = TreeNode(1)
    root.right = TreeNode(2)
    root.right.left = TreeNode(3)  # 输入：[1,null,2,3]
    # 测试递归中序遍历
    s = Solution()
    res = s.inorderTraversal(root)
    print(res)  # 输出: [1, 3, 2]
    # 示例2
    r2 = None  # 输入：[]
    res2 = s.inorderTraversal(r2)
    print(res2)  # 输出：[]
    # 示例3
    r3 = TreeNode(1)  # 输入：[1]
    res3 = s.inorderTraversal(r3)
    print(res3)  # 输出：[1]

方法2：迭代

from typing import Optional, List


# 定义二叉树节点
class TreeNode:
    def __init__(self, val=0, left=None, right=None):
        self.val = val
        self.left = left
        self.right = right


# 迭代
class Solution:
    def inorderTraversal(self, root: Optional[TreeNode]) -> List[int]:
        res = []
        if not root:  # 空树
            return []
        stack = []  # 栈
        while stack or root:
            while root:
                stack.append(root)  # 节点入栈
                root = root.left
            root = stack.pop()   # 节点弹栈
            res.append(root.val)
            root = root.right
        return res


if __name__ == "__main__":
    # 构造测试二叉树 示例1
    root = TreeNode(1)
    root.right = TreeNode(2)
    root.right.left = TreeNode(3)  # 输入：[1,null,2,3]
    # 测试递归中序遍历
    s = Solution()
    res = s.inorderTraversal(root)
    print(res)  # 输出: [1, 3, 2]
    # 示例2
    r2 = None  # 输入：[]
    res2 = s.inorderTraversal(r2)
    print(res2)  # 输出：[]
    # 示例3
    r3 = TreeNode(1)  # 输入：[1]
    res3 = s.inorderTraversal(r3)
    print(res3)  # 输出：[1]

121. 买卖股票的最佳时机

给定一个数组 prices，它的第 i 个元素 prices[i] 表示一支给定股票第 i 天的价格。
你只能选择 某一天 买入这只股票，并选择在未来的某一个不同的日子卖出该股票。设计一个算法来计算你所能获取的最大利润。
返回你可以从这笔交易中获取的最大利润。如果你不能获取任何利润，返回 0 。

示例 1：

输入：[7,1,5,3,6,4]
输出：5
解释：在第 2 天（股票价格 = 1）的时候买入，在第 5 天（股票价格 = 6）的时候卖出，最大利润 = 6-1 = 5 。
注意利润不能是 7-1 = 6, 因为卖出价格需要大于买入价格；同时，你不能在买入前卖出股票。

示例 2：

输入：prices = [7,6,4,3,1]
输出：0
解释：在这种情况下, 没有交易完成, 所以最大利润为 0。

提示：

1 <= prices.length <= 10(5)
0 <= prices[ i ] <= 10(4)

代码

from typing import List


class Solution:
    def maxProfit(self, prices: List[int]) -> int:
        smin = prices[0]  # 初始买入价默认第一天
        profit = 0  # 初始利润默认0
        for i in prices:
            if i < smin:
                smin = i  # 获取最小买入价
            if i - smin > profit:
                profit = i - smin  # 计算利润
        return profit


if __name__ == "__main__":
    # 121.买卖股票的最佳时机 示例1
    prices = [7, 1, 5, 3, 6, 4]
    a = Solution()
    res = a.maxProfit(prices)
    print(res)  # 输出：5
    # 示例2
    p2 = [7, 6, 4, 3, 1]
    r2 = a.maxProfit(p2)
    print(r2)  # 输出：0