LeetCode 热题 HOT 100笔记（简单篇）

🔥 LeetCode 热题 HOT 100

简单篇

1. 两数之和

给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出 和为目标值 target  的那两个整数，
并返回它们的数组下标。
你可以假设每种输入只会对应一个答案。但是，数组中同一个元素在答案里不能重复出现。
你可以按任意顺序返回答案。
输入：nums = [2,7,11,15], target = 9
输出：[0,1]
解释：因为 nums[0] + nums[1] == 9 ，返回 [0, 1] 。

class Solution:
    def twoSum(self, nums: List[int], target: int) -> List[int]:
        hashtable = dict()		# 哈希表解法 python
        for i, num in enumerate(nums):
            if target-num in hashtable:
                return [hashtable[target-num], i]
            else:
                hashtable[nums[i]] = i
        return []

解题思路：创建一个哈希表，对于每一个 num，我们首先查询哈希表中是否存在 target - num，
然后将 num 插入到哈希表中，即可保证不会让 x 和自己匹配。
扩展：dict() 字典相当于 Java常用的哈希表Hashtable
Dict是一个键值对元素的集：
1.键必须是唯一的，值可以是任意的；
2.键必须是不可变对象，比如数字、字符串或元组(纯元组，没有嵌套可变对象)；
3.Dict内部元素的存放顺序与元素的添加顺序无关。

dict()详情可见：Python之dict操作

20. 有效的括号

给定一个只包括 '('，')'，'{'，'}'，'['，']' 的字符串 s ，判断字符串是否有效。
有效字符串需满足
左括号必须用相同类型的右括号闭合。
左括号必须以正确的顺序闭合。
输入：s = "()"
输出：true

class Solution: 
    def isValid(self, s: str) -> bool:
        if len(s) % 2 == 1:   # Python 栈方法
            return False
        pairs = {
   
            ")": "(",
            "]": "[",
            "}": "{",
        }
        '''
        创建栈stack，对于字符串s的每个字符，是)]} 在Hashtable中的，
若栈为空（没匹配）或栈顶元素不匹配（定义在了Hashtable中了），就返回false，否则就出栈表示匹配。
        对于字符串s的每个字符，若不是)]}，即为([{，那么就进栈，等待匹配。
        '''
        stack = list()
        for ch in s:
            if ch in pairs:
                if not stack or stack[-1]!=pairs[ch]:
                    return False
                stack.pop()
            else:
                stack.append(ch)
        return not stack

解题思路：当我们遇到一个右括号时，我们需要将一个相同类型的左括号闭合。
此时，我们可以取出栈顶的左括号并判断它们是否是相同类型的括号。
如果不是相同的类型，或者栈中并没有左括号，那么字符串s无效，返回 False。
为了快速判断括号的类型，我们可以使用哈希表存储每一种括号。哈希表的键为右括号，值为相同类型的左括号。
1. 遍历结束后，如果栈中没有左括号，说明我们将字符串 s 中的所有左括号闭合，
返回True，否则返回False。
2. 意到有效字符串的长度一定为偶数，因此如果字符串的长度为奇数，
我们可以直接返回False，省去后续的遍历判断过程。

21. 合并两个有序链表

将两个升序链表合并为一个新的 升序 链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。
输入：l1 = [1,2,4], l2 = [1,3,4]
输出：[1,1,2,3,4,4]

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution:
    def mergeTwoLists(self, list1: Optional[ListNode], list2: Optional[ListNode]) -> Optional[ListNode]:
        if list1 is None:
            return list2
        elif list2 is None:
            return list1
        elif list1.val < list2.val:
            list1.next = self.mergeTwoLists(list1.next, list2)
            return list1
        else:
            list2.next = self.mergeTwoLists(list1, list2.next)
            return list2

# 递归
1. 如果 l1 或者 l2 一开始就是空链表 ，那么没有任何操作需要合并，所以我们只需要返回非空链表。
2. 判断 l1 和 l2 哪一个链表的头节点的值更小，然后递归地决定下一个添加到结果里的节点。
如果两个链表有一个为空，递归结束。

53. 最大子数组和

给你一个整数数组 nums，请你找出一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和。
子数组 是数组中的一个连续部分。
输入：nums = [-2,1,-3,4,-1,2,1,-5,4]
输出：6
解释：连续子数组 [4,-1,2,1] 的和最大，为 6 。

class Solution {
   
    public int maxSubArray(int[] nums) {
   
        int pre = 0, maxAns = nums[0];
        for (int x : nums) {
   
            pre = Math.max(pre + x, x);
            maxAns = Math.max(maxAns, pre);
        }
        return maxAns;
    }
}

动态规划解法。先设置maxAns=num[0]为初始最大值打擂台选出最大。
加强for循环内，pre表示前序最大的连续子数组和，因此只需比较 pre+x 和 x 即可。

70. 爬楼梯

假设你正在爬楼梯。需要 n 阶你才能到达楼顶。
每次你可以爬 1 或 2 个台阶。你有多少种不同的方法可以爬到楼顶呢？
注意：给定 n 是一个正整数。
输入： 2
输出： 2
解释： 有两种方法可以爬到楼顶。
1.  1 阶 + 1 阶
2.  2 阶

class Solution {
   
    public int climbStairs(int n) {