【Task04】LeetCode腾讯精选打卡

一、No0016. 最接近的三数之和

题目

给定一个包括 n 个整数的数组 nums 和 一个目标值 target。找出 nums 中的三个整数，使得它们的和与 target 最接近。返回这三个数的和。假定每组输入只存在唯一答案。

示例

• 输入：nums = [-1,2,1,-4], target = 1
• 输出：2
• 解释：与 target 最接近的和是 2 (-1 + 2 + 1 = 2) 。

提示

• 3 <= nums.length <= 10^3
• -10^3 <= nums[i] <= 10^3
• -10^4 <= target <= 10^4

解题代码(Python3)

class Solution:
    def threeSumClosest(self, nums: List[int], target: int) -> int:
        nums.sort()
        #初始化
        res = 10**4+1
        #用来判断最接近target的数
        def judgeClose(a,b):
            return a if abs(a-target) < abs(b-target) else b
        #子函数 相当于最接近target-value的2个数
        def returnCloseValue(left,right,value):
            #用res来存最接近target的值
            res = num + nums[left] + nums[right]
            while left < right:
                tmp = num + nums[left] + nums[right]
                if tmp > target:
                    right -= 1
                elif tmp < target:
                    left += 1
                #如果等于target 直接返回target
                else:
                    return target
                res = judgeClose(res,tmp)
            return res
        for i, num in enumerate(nums[:-2]):
            #这里大于0是防止对第一个位置判断有误 如果重复则continue
            if i > 0 and num == nums[i-1]:
                continue
            temp = returnCloseValue(i + 1,len(nums) - 1,num)
            if temp == target:
                return target
            else:
                res = judgeClose(res,temp)
        return res

思路：

这题与15题很类似，求三个数a+b+c，使得其和与target最接近，可以先将整个nums进行排序，然后最外层循环固定为a，简化成求另外两个数和target-a的最小差值

复杂度分析：

• 时间复杂度O(n^2)
• 空间复杂度O(1)

运行结果：

二、No0020. 有效的括号

题目

给定一个只包括 ‘(’，’)’，’{’，’}’，’[’，’]’ 的字符串，判断字符串是否有效。

有效字符串需满足：

1. 左括号必须用相同类型的右括号闭合。
2. 左括号必须以正确的顺序闭合。

注意空字符串可被认为是有效字符串。

示例 1

• 输入: “()”
• 输出: true

示例 2

• 输入: “()[]{}”
• 输出: true

示例 3

• 输入: “(]”
• 输出: false

示例 4

比较重要

• 输入: “([)]”
• 输出: false

示例 5

• 输入: “{[]}”
• 输出: true

提示

• 0 <= strs.length <= 200
• 0 <= strs[i].length <= 200
• strs[i] 仅由小写英文字母组成

解题代码(Python3)

class Solution:
    def isValid(self, s: str) -> bool:
        #栈
        stack = []
        pattern_dict = dict(zip(list(')]}'),list('([{')))
        for x in s:
        	#如果是左括号，直接入栈
            if x in pattern_dict.values():
                stack += x
            else:
                if len(stack) == 0:
                    return False
                if stack[-1] == pattern_dict[x]:
                    #这里pop是O(1)
                    stack.pop()
                else:
                    return False
        #最后注意要对栈进行检查
        return True if len(stack) == 0 else False

思路：

利用栈去做匹配，左括号直接入栈；右括号要进行判别，如果与栈顶元素与该右括号匹配，则栈顶元素进行出栈，否则直接返回False。

另外在循环后，要对栈进行判空操作。

复杂度分析：

• 时间复杂度O(n/2) = O(n)
• 空间复杂度O(1)

其他想法：

如果使用del stack[-1]，那么时间复杂度会变为O(n^2)，验证效果如下：

三、No0021. 合并两个有序链表

题目

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

示例 1

• 输入：l1 = [1,2,4], l2 = [1,3,4]
• 输出：[1,1,2,3,4,4]

示例 2

• 输入：l1 = [], l2 = []
• 输出：[]

示例 3

• 输入：l1 = [], l2 = [0]
• 输出：[0]

提示

• 两个链表的节点数目范围是 [0, 50]
• -100 <= Node.val <= 100
• l1 和 l2 均按 非递减顺序 排列

解题代码(Python3)

class Solution:
    def mergeTwoLists(self, l1: ListNode, l2: ListNode) -> ListNode:
        if not l1:
            return l2
        if not l2:
            return l1
        if l1.val <= l2.val:
            p = head = l1
            l1 = l1.next
        else:
            p = head = l2
            l2 = l2.next
        while l1 and l2:
            if l1.val <= l2.val:
                head.next = l1
                l1 = l1.next
            else:
                head.next = l2
                l2 = l2.next                
            head = head.next
        else:
            #不可能同时为空
            if l1:
                head.next = l1
            else:
                head.next = l2
        return p

思路：

第一步，如果l1或l2为空，那么返回l2或l1；
第二步，新建p和head为头指针，然后根据大小分别对l1和l2进行连接；
第三步，将l1和l2剩余的部分接入p中，注意此时由于跳出循环，l1和l2只有一个非空。

复杂度分析：

• 时间复杂度O(n)
• 空间复杂度O(1)

运行结果：