task04，leetcode:16,20,21

16.最接近的三数之和

与三数之和非常相似的题目，均为双指针。
代码中给出了部分剪枝操作，可以稍作了解，思考一下剪掉的是什么。

class Solution:
    def threeSumClosest(self, nums: List[int], target: int) -> int:
        nums.sort()									# 排序的意义是方便后面双指针可以使用
        n = len(nums)
        best = float('inf')                         # 记录与target差最小的和
        for left in range(n):
            # 下面的if判断是剪枝的作用，提前中断重复条件，没有也阔以
            if left > 0 and nums[left] == nums[left - 1]:
                continue

            mid, right = left + 1, n - 1
            while mid < right:
                cur_sum = nums[left] + nums[mid] + nums[right]

                # 三者和与target相等时直接返回就可以，因为差值为0
                if cur_sum == target:               
                    return target

                # 当与target差值更小时更新best
                if abs(cur_sum - target) < abs(best - target):
                    best = cur_sum

                # 三者和比target大时，需要缩小，所以右指针左移
                if cur_sum > target:
                    right -= 1

                    # 下面四行与上面等价，只不过做了剪枝操作。提前退出相邻元素相等的情况
                    # temp = right - 1
                    # while temp > mid and nums[temp] == nums[right]:
                    #     temp -= 1
                    # right = temp
                else:
                    # 同为剪枝操作，改为left += 1是一样的效果
                    temp = mid + 1
                    while temp < right and nums[temp] == nums[mid]:
                        temp += 1
                    mid = temp
        return best

20.有效的括号

栈stack(先进后出的数据结构)的经典入门题目，与此类似的是队列（deque）（先进先出的数据结构）

class Solution:
    def isValid(self, s: str) -> bool:
        stack = []                          # 使用栈来记录当前的遍历情况
        match = {')':'(', ']':'[', '}':'{'} # 用来记录左右括号的配对关系
        for ch in s:
            if ch in '([{':                 # 如果是左括号，则入栈
                stack.append(ch)
            else:                           # 右括号时
                if stack and stack[-1] == match[ch]: # 如果栈非空且匹配，则弹出
                    stack.pop()
                else:                       # 栈空或者不匹配，直接返回False
                    return False
        # 结束后栈空则表示完全匹配，不空则表示有多余的左括号
        return len(stack) == 0              

时间复杂度O(n),空间复杂度O(n)。

21.合并两个有序链表

与2.两数相加比较类似，参照那题吧

# 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, l1: ListNode, l2: ListNode) -> ListNode:
        #### 这题就不详细写了吧，参照2.两数相加
        dummyhead = temp = ListNode(0)         
        while l1 and l2:
            val1, val2 = l1.val, l2.val
            if val1 < val2:
                temp.next = l1
                l1 = l1.next
            else:
                temp.next = l2
                l2 = l2.next
            temp = temp.next
        while l1:
            temp.next = l1
            temp, l1 = temp.next, l1.next
        while l2:
            temp.next = l2
            temp, l2 = temp.next, l2.next
        return dummyhead.next

时间复杂度O(m+n)，空间复杂度O(1)。

标签：20,target,temp,nums,16,next,l2,l1,task04
来源： https://blog.csdn.net/juanjuanyou/article/details/112549485