LeetCode腾讯精选50题---23,26,33

Day05

23. 合并K个升序链表 (diffculty)

合并K个升序链表 (diffculty)
思路：

• 暴力法,先把链表遍历取出放进数组中,然后把数组排序,然后再遍历数组重新放进新的链表中。
• 堆排序,基于堆的特点heap[0]堆的第一个元素永远是最小的元素.首先遍历链表,把所有val加入到堆中,然后逐一删除并加到新链表即可。与暴力法相当,这里运用堆的特性与暴力法中排序相似.
• 分治法(需重点理解,思路非常重要),此题为k个链表进行排序,参考第21题可知,尝试把两两相加,形成新的链表.
  • 例如[[1,4,5],[1,3,4],[2,6], [3, 7]],先把[1,4,5],[1,3,4]两个链表相加为[1,1,3,4,4,5].把[2,6],[3,7]两个链表相加为[2,3,6,7]；
  • 然后再变成[1,1,3,4,4,5]和[2,3,6,7]两个链表相加.此时就把k个链表相加简化为多个的(两个链表相加)；
  • 这里对总链表lists使用二分法,取中间节点对左右进行累加最终加完。

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

    示例 1：
    输入：lists = [[1,4,5],[1,3,4],[2,6]]
    输出：[1,1,2,3,4,4,5,6]
    解释：链表数组如下：
    [
      1->4->5,
      1->3->4,
      2->6
    ]
    将它们合并到一个有序链表中得到。
    1->1->2->3->4->4->5->6

    示例 2：
    输入：lists = []
    输出：[]

    示例 3：
    输入：lists = [[]]
    输出：[]


    提示：
    k == lists.length
    0 <= k <= 10^4
    0 <= lists[i].length <= 500
    -10^4 <= lists[i][j] <= 10^4
    lists[i] 按 升序 排列
    lists[i].length 的总和不超过 10^4
"""
from typing import List


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


class Solution_baoli(object):
    # 思路:先把链表遍历取出放进数组中,然后把数组排序,然后再遍历数组重新放进新的链表中。
    # Time complexity: O(NlogN), 遍历链表需要O(N),排序需要O(NlogN),遍历同时创建新的有序链表O(N)
    # Space complexity: O(N)
    def mergeKLists(self, lists: List[ListNode]) -> ListNode:
        """
        :type lists: List[ListNode]
        :rtype: ListNode
        """

        # 数组初始化
        arr = []
        # res为保存结果,cur为可移动的结果
        res = cur = ListNode(0)

        # 遍历链表,并把每个遍历结果添加到数组中
        for l in lists:
            while l:
                arr.append(l.val)
                l = l.next

        # 对数组进行排序操作,同时逐一放到新创建的链表
        for i in sorted(arr):
            cur.next = ListNode(i)
            cur = cur.next

        return res.next


class Solution_heap_rank(object):
    # 思路:堆排序,基于堆的特点heap[0]堆的第一个元素永远是最小的元素.首先遍历链表,把所有val加入到堆中,然后逐一删除并加到新链表即可。
    # 具体思路与暴力法相当,这里运用堆的特性与暴力法中排序相似.
    # Time complexity: O(NlogN)
    # Space complexity: O(N)
    def mergeKLists(self, lists: List[ListNode]) -> ListNode:
        """
        :type lists: List[ListNode]
        :rtype: ListNode
        """
        # 引用python堆模块heapq
        import heapq

        # res为保存结果,cur为可移动的结果
        res = cur = ListNode(0)

        heapq_ = []

        # 遍历链表并加入堆中
        for l in lists:
            while l:
                heapq.heappush(heapq_, l.val)
                l = l.next

        # 从堆中每次取第一个元素同时加到新链表
        while heapq_:
            val = heapq.heappop(heapq_)
            cur.next = ListNode(val)
            cur = cur.next

        return res.next

class Solution_divide(object):
    # 思路:分治法,此题为k个链表进行排序,参考第21题可知,尝试把两两相加,形成新的链表.
    # 例如[[1,4,5],[1,3,4],[2,6], [3, 7]],先把[1,4,5],[1,3,4]两个链表相加为[1,1,3,4,4,5].把[2,6],[3,7]两个链表相加为[2,3,6,7].
    # 然后再变成[1,1,3,4,4,5]和[2,3,6,7]两个链表相加.此时就把k个链表相加简化为多个的(两个链表相加).
    # 这里使用二分法,取中间节点对左右进行累加最终加完
    # Time complexity: O(NlogN)
    # Space complexity: O(N)
    def mergeKLists(self, lists: List[ListNode]) -> ListNode:
        """
        :type lists: List[ListNode]
        :rtype: ListNode
        """

        length = len(lists)

        if length == 0:
            return None

        if length == 1:
            return lists[0]

        if length == 2:
            return self.mergeTwoLists(lists[0], lists[1])

        # 二分法,取中间节点对左右进行累加最终加完
        mid = length // 2

        return self.mergeTwoLists(self.mergeKLists(lists[:mid]), self.mergeKLists(lists[mid:length]))

    def mergeTwoLists(self, l1: ListNode, l2: ListNode) -> ListNode:
        # 与第21题两链表相加一模一样
        """
        :type l1: ListNode[1,2,3]
        :type l2: ListNode[1,4,5]
        :rtype: ListNode
        """

        res = cur = ListNode(0)

        while l1 and l2:
            if l1.val <= l2.val:
                cur.next = l1
                l1 = l1.next
            else:
                cur.next = l2
                l2 = l2.next

            cur = cur.next

        cur.next = l1 if l1 else l2

        return res.next

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

26. 删除排序数组中的重复项 (Easy)
思路:双指针,从0,1开始对数组进行遍历,若两数相等,则第二指针往右走1步,若不相等,则左指针往右走一步,且此时左指针的数字更换为有指针的数字.

"""
    给定一个排序数组，你需要在 原地 删除重复出现的元素，使得每个元素只出现一次，返回移除后数组的新长度。
    不要使用额外的数组空间，你必须在 原地 修改输入数组 并在使用 O(1) 额外空间的条件下完成。

    示例 1:
    给定数组 nums = [1,1,2],
    函数应该返回新的长度 2, 并且原数组 nums 的前两个元素被修改为 1, 2。
    你不需要考虑数组中超出新长度后面的元素。

    示例 2:
    给定 nums = [0,0,1,1,1,2,2,3,3,4],
    函数应该返回新的长度 5, 并且原数组 nums 的前五个元素被修改为 0, 1, 2, 3, 4。
    你不需要考虑数组中超出新长度后面的元素。

    说明:
    为什么返回数值是整数，但输出的答案是数组呢?
    请注意，输入数组是以「引用」方式传递的，这意味着在函数里修改输入数组对于调用者是可见的。
    你可以想象内部操作如下:

    // nums 是以“引用”方式传递的。也就是说，不对实参做任何拷贝
    int len = removeDuplicates(nums);
    // 在函数里修改输入数组对于调用者是可见的。
    // 根据你的函数返回的长度, 它会打印出数组中该长度范围内的所有元素。
    for (int i = 0; i < len; i++) {
        print(nums[i]);
    }
"""
from typing import List


class Solution(object):
    # 双指针,从0,1开始对数组进行遍历,若两数相等,则第二指针往右走1步,若不相等,则左指针往右走一步,且此时左指针的数字更换为有指针的数字.
    # Time complexity: O(N)
    # Space complexity: O(1)
    def removeDuplicates(self, nums: List[int]) -> int:
        """
        :type nums: List[int]
        :rtype: int
        """

        i, j = 0, 1

        while j < len(nums):
            if nums[j] == nums[i]:
                j += 1

            else:
                i += 1
                nums[i] = nums[j]
        return i + 1 

33. 搜索旋转排序数组 (Medium)

33. 搜索旋转排序数组 (Medium)
思路:二分搜索法(PS:初次接触二分搜索法,全是细节,一个等号真的要我老命了…~吐血了)

• 先通过求出中间结点即二分结点来对有序数组进行判断;
• 根据比较左结点、右结点和中间结点的大小关系;
• 因为数组是随机旋转的,所以二分以后以二分结点为界的左或右必然有一段是有序的(左结点到中间结点或中间结点到右结点);
  • 若nums[mid] >= nums[left]则说明左结点到中间结点为有序,否则说明中间结点到右结点是有序的.
• 此时针对两种情况进行判断,并判断target是否处于两端点之间:
  • 即nums[left]<=target<nums[mid],则说明target在左边,此时右结点需要更新到mid-1;
  • 若nums[mid]<target<=nums[right], 则说明target在右边,此时左结点需要更新到mid+1.

由于题目中出现搜索、排序等字眼,对于有序数组或者部分有序数组进行搜索,基本可以使用二分搜索及其变种来进行处理。因为通过暴力解法,可知解决方法的时间复杂度上限为O(N),通过优化目标为O(logN)二分搜索方法来达到目的。二分搜索的核心每次只搜索一半的数据,相当于丢弃一半的数据,使得搜索空间减半。

"""
    升序排列的整数数组 nums 在预先未知的某个点上进行了旋转（例如， [0,1,2,4,5,6,7] 经旋转后可能变为 [4,5,6,7,0,1,2] ）。
    请你在数组中搜索 target ，如果数组中存在这个目标值，则返回它的索引，否则返回 -1 。

    示例 1：
    输入：nums = [4,5,6,7,0,1,2], target = 0
    输出：4

    示例 2：
    输入：nums = [4,5,6,7,0,1,2], target = 3
    输出：-1

    示例 3：
    输入：nums = [1], target = 0
    输出：-1

    提示：
    1 <= nums.length <= 5000
    -10^4 <= nums[i] <= 10^4
    nums 中的每个值都 独一无二
    nums 肯定会在某个点上旋转
    -10^4 <= target <= 10^4
"""
from typing import List


class Solution_baoli(object):
    # 暴力法,遍历数组,没啥好说的,但不符合题目的时间复杂度O(logN)
    # Time complexity: O(N)
    # Space complexity: O(1)
    def search(self, nums: List[int], target: int) -> int:
        """
        :type nums: List[int]
        :type target: int
        :rtype: int
        """

        for i in range(len(nums)):
            if nums[i] == target:
                return i

        return -1


class Solution_bisnary_search(object):
    # 二分搜索法
    # Time complexity: O(logN)
    # Space complexity: O(1)
    def search(self, nums: List[int], target: int) -> int:
        """
        :type nums: List[int]
        :type target: int
        :rtype: int
        """

        if len(nums) == 0:
            return -1

        left, right = 0, len(nums) - 1

        while left < right:
            mid = left + (right - left) // 2
            if nums[mid] == target:
                return mid

            # 左结点值比二分结点小,说明左边为有序
            if nums[left] <= nums[mid]:
                # 若target处于nums[left]和num[mid]之间,则说明target在左边有序中,此时右结点更新为mid - 1
                if nums[left] <= target < nums[mid]:
                    right = mid - 1
                # 否则则target在右侧无序中,此时左结点更新为mid + 1
                else:
                    left = mid + 1
            # 以下同理
            else:
                if nums[mid] < target <= nums[right]:
                    left = mid + 1
                else:
                    right = mid - 1

        return left if nums[left] == target else -1

参考资料
1
2
3