leetcode python刷题记录（三） 21~30

21. 合并两个有序链表

class Solution:
    def mergeTwoLists(self, list1: Optional[ListNode], list2: Optional[ListNode]) -> Optional[ListNode]:
        # 当变为空列表时结束递归，返回列表
        if not list1:
            return list2
        if not list2:
            return list1

        # 递归调用
        # 如何递归：我们判断 l1 和 l2 头结点哪个更小，然后较小结点的 next 指针指向其余结点的合并结果。（调用递归）
        if(list1.val <= list2.val):
            list1.next = self.mergeTwoLists(list1.next, list2)
            return list1
        else:
            list2.next = self.mergeTwoLists(list1, list2.next)
            return list2

22. 括号生成

dfs：

class Solution:
    def generateParenthesis(self, n: int) -> List[str]:
        res=[]
        cur_str=''

        # left，right表示当前左括号的数量与右括号的数量
        def dfs(cur_str,left,right):
            # 达到n后停止dfs
            if left ==n and right==n:
                res.append(cur_str)
                return 

            # 必须保证当前字符串左括号数量大于右括号数量方可继续，否则停止dfs
            # 任意一个子序列，右括号的数目必须小于等于左括号的数目
            if left<right:
                return

            # dfs
            if left<n:
                dfs(cur_str+'(',left+1,right)
            if right<n:
                dfs(cur_str+')',left,right+1)

        dfs(cur_str,0,0)
        return res

23. 合并K个升序链表

在链表的操作中，添加一个哑节点(dummy),让它的指针指向链表的头节点

好处：

• 省略头节点为空时的情况的判断；

• 头节点和其他节点进行同样的操作时，由于头节点没有前一个节点，需要对这种情况进行单独判断，但加入虚拟节点以后，头节点就可以当作普通节点看待。

class Solution:
    def mergeKLists(self, lists: List[Optional[ListNode]]) -> Optional[ListNode]:
        nums=[]
        # 放到一个数组里排序
        for l in lists:
            node=l
            while node:
                nums.append(node.val)
                node=node.next

        nums.sort()

        # 放到一个链表里
        dummy=ListNode(0)
        head=dummy
        for i in range(len(nums)):
            head.next=ListNode(nums[i])
            # 等价于，先创建节点，再连接
            # tmp=ListNode()
            # tmp.val=nums[i]
            # head.next=tmp
            head=head.next

        return dummy.next

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

class Solution:
    def swapPairs(self, head: Optional[ListNode]) -> Optional[ListNode]:

        dummy = ListNode(0)
        dummy.next = head

        p = dummy
        while p and p.next and p.next.next:
            a = p.next
            b = p.next.next

            p.next = b
            a.next = b.next
            b.next = a

            p = a

        return dummy.next