【datawhale】数据结构打卡任务1

• 练习： Three Sum（求三数之和）

中文版：https://leetcode-cn.com/problems/3sum/

数组排序后固定一个数，这个固定的数从索引0开始取，另外两个数通过双指针进行搜索，当然，还要考虑重复的情况

class Solution:
    def threeSum(self, nums: List[int]) -> List[List[int]]:
        nums.sort()#排序
        res=[]#建立空数组
        for i in range(len(nums)-2):#第一个数索引最大只能取len(nums)-2
            if i>0 and nums[i]==nums[i-1]:
                continue
            j=i+1#确定双指针索引
            k=len(nums)-1
            while j<k:
                if nums[i]+nums[j]+nums[k]==0:#
                    res.append([nums[i],nums[j],nums[k]])
                    while j<k and nums[j]==nums[j+1]:
                        j+=1
                    while j<k and nums[k]==nums[k-1]:
                        k-=1
                    j+=1
                    k-=1
                elif nums[i]+nums[j]+nums[k]>0:
                    k-=1
                else:
                    j+=1
        return res

Majority Element（求众数）

 

中文版：https://leetcode-cn.com/problems/majority-element/

题目假设有众数且数组不为空，可排序后中位数总为众数（题目规定众数为出现次数大于len(nums)/2）

class Solution:
    def majorityElement(self, nums: List[int]) -> int:
        nums.sort()
        n=len(nums)
        return nums[n//2]#取整

Missing Positive（求缺失的第一个正数）[作为可选]打卡来不及了，等下来做

英文版：https://leetcode.com/problems/first-missing-positive/

中文版：https://leetcode-cn.com/problems/first-missing-positive/

• 【链表】

实现单链表、循环链表、双向链表，支持增删操作

实现单链表反转

实现两个有序的链表合并为一个有序链表

实现求链表的中间结点

• 练习： Linked List Cycle I（环形链表）

中文版：https://leetcode-cn.com/problems/linked-list-cycle/

（快慢指针法，若指针相遇则判断有环）

class Solution(object):
    def hasCycle(self, head):
        slow = fast = head
        while slow and fast and fast.next:
            slow = slow.next
            fast = fast.next.next
            if slow == fast:
                return True
        return False

 

Merge k Sorted Lists（合并 k 个排序链表）

 

中文版：https://leetcode-cn.com/problems/merge-k-sorted-lists/

优先级队列

时间复杂度：O(n∗log(k))O(n*log(k))O(n∗log(k))，n 是所有链表中元素的总和，k 是链表个数。

# 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 heapq
        dummy = ListNode(0)
        p = dummy
        head = []
        for i in range(len(lists)):
            if lists[i] :
                heapq.heappush(head, (lists[i].val, i))
                lists[i] = lists[i].next
        while head:
            val, idx = heapq.heappop(head)
            p.next = ListNode(val)
            p = p.next
            if lists[idx]:
                heapq.heappush(head, (lists[idx].val, idx))
                lists[idx] = lists[idx].next
        return dummy.next