力扣（2024.06.12）

1. 20——有效的括号

给定一个只包括 '('，')'，'{'，'}'，'['，']' 的字符串 s ，判断字符串是否有效。有效字符串需满足：

1. 左括号必须用相同类型的右括号闭合。
2. 左括号必须以正确的顺序闭合。
3. 每个右括号都有一个对应的相同类型的左括号。

标签：栈，字符串

代码：

class Solution:
    def isValid(self, s: str) -> bool:
        stack = []
        pair = {'[': ']', '(': ')', '{': '}'}
        for i in s:
            if i in '([{':
                stack.append(pair[i])
            else:
                if stack == []:
                    return False
                else:
                    if stack[-1] == i:
                        stack.pop()
                    else:
                        return False
        if stack != []:
            return False
        else:
            return True

2. 21——合并两个有序链表

将两个升序链表合并为一个新的升序链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。

标签：链表，迭代

代码：

# 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]:
        dummy = res = ListNode()
        while list1 and list2:
            if list1.val < list2.val:
                res.next = list1
                list1 = list1.next
            else:
                res.next = list2
                list2 = list2.next
            res = res.next
        if list1:
            res.next = list1
        if list2:
            res.next = list2
        return dummy.next

3. 22——括号生成

数字 n 代表生成括号的对数，请你设计一个函数，用于能够生成所有可能的并且有效的括号组合。

标签：字符串，动态规划，回溯（目前不会）

代码：

4. 23——合并K个升序链表

给你一个链表数组，每个链表都已经按升序排列。请你将所有链表合并到一个升序链表中，返回合并后的链表。

标签：链表，迭代

代码：

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution:
    def mergeKLists(self, lists: List[Optional[ListNode]]) -> Optional[ListNode]:
        def merge_two(list1, list2):
            dummy = res = ListNode()
            while list1 and list2:
                if list1.val < list2.val:
                    res.next = list1
                    list1 = list1.next
                else:
                    res.next = list2
                    list2 = list2.next
                res = res.next
            if list1:
                res.next = list1
            if list2:
                res.next = list2
            return dummy.next
        res = ListNode()  # 初始化一个链表，只有一个值为0的结点
        res = res.next
        for i in range(len(lists)):
            res = merge_two(res, lists[i])
        return res

5. 24——两两交换链表中的节点

给你一个链表，两两交换其中相邻的节点，并返回交换后链表的头节点。你必须在不修改节点内部的值的情况下完成本题（即，只能进行节点交换）。

标签：链表，迭代

代码：

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution:
    def swapPairs(self, head: Optional[ListNode]) -> Optional[ListNode]:
        dummy = res = ListNode()
        while head and head.next:  # 链表至少有两个结点才能进入循环
            node1 = head
            node2 = head.next
            node3 = head.next.next
            res.next = node2
            node1.next = node3
            node2.next = node1
            res = res.next.next
            head = node3
        res.next  = head  # 链表有空结点或一个结点就不进入循环直接执行这句
                          # 链表两两交换后不剩余结点或剩余一个结点也是执行这句
        return dummy.next