leetcode 第23、26、33题 Python

23. 合并K个升序链表

给你一个链表数组，每个链表都已经按升序排列。
请你将所有链表合并到一个升序链表中，返回合并后的链表。

class Solution:
    def mergeKLists(self, lists: List[ListNode]) -> ListNode:
        if not lists:return 
        n = len(lists)
        output = self.merge(lists, 0, n-1)
        return output
    def merge(self, lists: List[ListNode], head: int, tail: int) -> ListNode:
        if head == tail:
            return lists[head]
        mid = head + (tail - head) // 2
        first_list = self.merge(lists, head, mid)
        second_list = self.merge(lists, mid + 1, tail)
        return self.merge_two_list(first_list, second_list)
    def merge_two_list(self, first_list, second_list):
        if not first_list:
            return second_list
        if not second_list:
            return first_list
        if first_list.val <= second_list.val:
            first_list.next = self.merge_two_list(first_list.next, second_list)
            return first_list
        else:
            second_list.next = self.merge_two_list(first_list, second_list.next)
            return second_list

改进一下，运行时间、内存消耗更优

class Solution:
    def mergeKLists(self, lists: List[ListNode]) -> ListNode:

        def __lt__(self, other):
            return self.val < other.val
        ListNode.__lt__ = __lt__
        
        import heapq
        heap = []
        dummy = ListNode(-1)
        p = dummy

        for l in lists:
            if l:
                heapq.heappush(heap, l)
        while heap:
            node = heapq.heappop(heap)
            p.next = ListNode(node.val)
            p = p.next
            if node.next:
                heapq.heappush(heap, node.next)
        
        return dummy.next

26. 删除排序数组中的重复项

给定一个排序数组，你需要在 原地 删除重复出现的元素，使得每个元素只出现一次，返回移除后数组的新长度。
不要使用额外的数组空间，你必须在 原地 修改输入数组 并在使用 O(1) 额外空间的条件下完成
思路：
降低执行用时的关键是运用“有序数组”这一点。运用快慢指针，快指针用于遍历数组，慢指针更新数组。首先将慢指针length置0，当快指针的数值等于慢指针的数值，继续遍历，否则慢指针+1，将快指针数值付给慢指针指向的位置。
这道题如果不要求，O(n) 的时间复杂度， O(1) 的空间复杂度的话，会很简单。 但是这道题是要求的，这种题的思路一般都是采用双指针

class Solution:
    def removeDuplicates(self, nums: List[int]) -> int:
        length = 0
        for i in range(1,len(nums)):
            if nums[i] == nums[length]:
                continue
            else:
                length += 1
                nums[length] = nums[i]
        return length+1

33. 搜索旋转排序数组

升序排列的整数数组 nums 在预先未知的某个点上进行了旋转（例如， [0,1,2,4,5,6,7] 经旋转后可能变为 [4,5,6,7,0,1,2] ）。
请你在数组中搜索 target ，如果数组中存在这个目标值，则返回它的索引，否则返回 -1 。
思路：（一开始看题都没有看懂。。。）
题目中隐含两个道理：1）从任何一个位置一分为二后，必然有一边是有序的，一边是无序的，并且无序的继续同样的操作，结论依然成立；2）对于升序排序的数组在预先未知的某个点上进行了旋转后的数组（不存在重复元素），如果数组的中位数大于数组的第一个值，则左边是有序的；否则，右边是有序的(这是对第一点的进一步理解分析结果）。
无论是左边有序还是右边有序，都可以容易判断出target是在左半部分还是右半部分，并且继续同样的判断操作，因此，解题方法用递归操作，简单易行。

class Solution(object):
    def search(self, nums, target):
        """
        :type nums: List[int]
        :type target: int
        :rtype: int
        """  
        return self.binarySearch(nums,0,len(nums)-1,target)
       
    # 新定义一个二分查找的函数
    def binarySearch(self,nums,left,right,target): 
        if left>right:
            return -1
        
        mid = (left+right)//2
        if nums[mid] == target:
            return mid
        
        if nums[mid]>=nums[left] :                            #左边是有序的 
            if nums[left]<=target and target<= nums[mid]:    # 判断目标值在左半部分
                return self.binarySearch(nums,left,mid-1,target)  # 递归，
            else :                                           # 否则，在右半部分
                return self.binarySearch(nums,mid+1,right,target)
        else:                                                #右边是有序的，同上述思想一致
            if nums[mid]<=target and target<=nums[right]:
                return self.binarySearch(nums,mid+1,right,target)
            else:
                return self.binarySearch(nums,left,mid-1,target)