【代码】hot100

Easy

两数之和

两数之和

class Solution:
    def twoSum(self, nums: List[int], target: int) -> List[int]:
        xdict={}
        for i in range(len(nums)):
            j=target-nums[i]
            if j in xdict.keys():
                return [i,xdict[j]]
            else:
                xdict[nums[i]]=i        

有效的括号

有效的括号

class Solution:
    def isValid(self, s: str) -> bool:
        map_dict={
            ')':'(',
            '}':'{',
            ']':'[',
        }
        st=[]
        for item in s:
            if item not in map_dict.keys():
                st.append(item)
            else:
                if not st:
                    return False
                pop_item=st.pop()
                if pop_item!=map_dict[item]:    
                    # 如果是嵌套括号的话，不能交错嵌套。如果不是交错嵌套的，内层的会正确被 pop 出来，所以只需要 pop 最后的那个就可以了。
                    return False
        return not st

合并两个有序链表

合并两个有序链表

# 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 not list1 and not list2:
        #     return None
        curr=ListNode()
        head=curr
        while list1 and list2:
            if list1.val<list2.val:
                curr.next=list1
                list1=list1.next
            else:
                curr.next=list2
                list2=list2.next
            curr=curr.next
        if list1:
            curr.next=list1
        if list2:
            curr.next=list2
        return head.next

爬楼梯

爬楼梯

class Solution:
    def climbStairs(self, n: int) -> int:
        if n==1:
            return 1
        if n==2:
            return 2
        dp=[0]*n
        dp[0]=1
        dp[1]=2
        for i in range(2,n):
            dp[i]=dp[i-1]+dp[i-2]
        return dp[n-1]

二叉树的中序遍历

二叉树的中序遍历

# Definition for a binary tree node.
# 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]:

        ret=[]
        def dfs(node):
            if not node:
                return
            dfs(node.left)
            ret.append(node.val)
            dfs(node.right)
        dfs(root)
        return ret

对称二叉树

对称二叉树

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def isSymmetric(self, root: Optional[TreeNode]) -> bool:
        if not root:
            return True

        def search(t1,t2):
            if not t1 and not t2:
                return True
            if not t1 or not t2:
                return False
            return t1.val==t2.val and search(t1.left,t2.right) and search(t1.right,t2.left)
        return search(root.left,root.right)

二叉树的最大深度

二叉树的最大深度

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def maxDepth(self, root: Optional[TreeNode]) -> int:
        if not root:
            return 0
        left_dep=self.maxDepth(root.left)
        right_dep=self.maxDepth(root.right)
        return max(left_dep,right_dep)+1
        # 加一的根本原因是：为了把当前节点所在的这一层计算进去。

买卖股票的最佳时机

买卖股票的最佳时机

class Solution:
    def maxProfit(self, prices: List[int]) -> int:
        max_ret=0
        min_cost=float('inf')    
        n=len(prices)
        for i in range(1,n):
            min_cost=min(min_cost,prices[i-1])
            max_ret=max(max_ret,prices[i]-min_cost)    
        return max_ret