LeetCode50题第四天

LeetCode第16题: 最接近的三数之和

1. 思想与三数之和类似, 使用双指针方法

class Solution:
    def threeSumClosest(self, nums, target):
        length = len(nums)
        nums.sort()
        print(nums)
        if target < nums[0] + nums[1] + nums[2]:
            return nums[0] + nums[1] + nums[2]
        if target > nums[length - 1] + nums[length - 2] + nums[length - 3]:
            return nums[length - 1] + nums[length - 2] + nums[length - 3]
        result = float('inf')
        i = 0
        while i < length - 2:
            j = i + 1
            k = length - 1
            inside = float('inf')
            while j < k:
                c = (nums[i] + nums[j] + nums[k])
                if abs(c - target) <= abs(inside - target):
                    inside = c
                if c < target:
                    j += 1
                    while nums[j] == nums[j - 1] and j < k:
                        j += 1
                elif c > target:
                    k -= 1
                    while nums[k] == nums[k + 1] and j < k:
                        k -= 1
                else:
                    return target
                # else:
                #     break
            i += 1
            while nums[i] == nums[i - 1] and i < length - 2:
                i += 1
            if abs(inside - target) < abs(result - target):
                result = inside
        return result

LeetCode第20题: 有效的括号

1. 使用栈匹配即可

class Solution:
    def isValid(self, s: str) -> bool:
        dic = {'(': 1, ')': -1, '[': 2, ']': -2, '{': 3, '}': -3}
        i = 0
        length = len(s)
        l = []
        while i < length:
            if dic[s[i]] > 0:
                l.append(s[i])
            else:
                if len(l) == 0 or dic[l.pop()] + dic[s[i]] != 0:
                    return False
            i += 1
        if len(l) != 0:
            return False
        return True
                    

复杂度分析: 设字符串长度为n, 由于需要将字符串遍历一遍, 所以复杂度为O(n)

LeetCode第21题: 合并两个有序链表

1. 思路类似归并排序, 将小的值插到大的前边

# 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:
        i = ListNode()
        i.next = l1
        pi = i
        j = ListNode()
        j.next = l2
        pj = j
        while pi.next != None and pj.next != None:
            if pi.next.val < pj.next.val:
                pi = pi.next
            else:
                mid = pj.next.next
                pj.next.next = pi.next
                pi.next = pj.next
                pj.next = mid
                pi = pi.next
        if pj.next != None:
            pi.next = pj.next
        return i.next

复杂度: 设两个链表的长度分别为n, m, 该算法需要将两个链表遍历一遍, 复杂度O(m + n)