编程实践笔记No.4

写在最前面，编程一直是我的短板，希望在leetcode练习中获得进步！

参考Datawhale组队学习中“LeetCodeTencent”

题目一 16. 最接近的三数之和

链接

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

排序 + 双指针

代码

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, x):
#         self.val = x
#         self.next = None

class Solution:
    def mergeKLists(self, lists: List[ListNode]) -> ListNode:
        import sys
        count = len(lists)
        if count == 0:
            return None
        pHead = ListNode(-1)
        temp = pHead
        while True:
            minValue = sys.maxsize
            minIndex = -1
            for i in range(count):
                if lists[i] is not None:
                    if lists[i].val<minValue :
                        minIndex = i
                        minValue = lists[i].val
            if minIndex == -1:
                break
            temp.next = lists[minIndex]
            temp = temp.next
            lists[minIndex] = lists[minIndex].next
        return pHead.next

参考链接
时间复杂度 O(N ^2)
空间复杂度 O(log N)
我的结果

题目二 20. 有效的括号

链接

判断字符串是否有效。一对括号。

思路

栈

1. 举例寻找规律
2. 先出现的后匹配
3. 模式识别：先出现的左括号后匹配

代码

class Solution:
    def isValid(self, s: str) -> bool:
        if len(s) % 2 == 1:
            return False
        
        pairs = {
            ")": "(",
            "]": "[",
            "}": "{",
        }
        stack = list()
        for ch in s:
            if ch in pairs:
                if not stack or stack[-1] != pairs[ch]:
                    return False
                stack.pop()
            else:
                stack.append(ch)
        
        return not stack

作者LeetCode-Solution链接：
我的结果
时间复杂度：O(n)
空间复杂度：O(n)

题目三 21. 合并两个有序链表

链接

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

代码

class Solution:
    def mergeTwoLists(self,l1,l2):
        pHead = ListNode(None) # 输出链表头指针
        temp = pHead    # 当下指针指向链表空表头
        while(l1 and l2): # 两个链表中都不为空
            if(l1.val <= l2.val): # 当下的指针所指的值 比较
                temp.next = l1
                l1 = l1.next
            else:
                temp.next = l2
                l2 = l2.next
            temp = temp.next
        # 其中一个链表遍历完全，另一个直接接上
        if l1 is not None:
            temp.next = l1
        else:
            temp.next = l2

        return pHead.next

我的结果