数据结构学习计划_入门_第二天_数组

原创已于 2022-08-24 10:28:43 修改 · 220 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#数据结构 #学习 #leetcode

于 2022-08-23 20:24:03 首次发布

本文介绍了如何使用Python解决LeetCode上的两数之和问题，通过哈希表和双指针方法，分别展示了字典实现和空间效率优化的方法。同时，讲解了合并两个有序数组的高效解决方案，包括直接排序和双指针技巧。

1.两数之和

https://leetcode.cn/problems/two-sum/
数组哈希表

给定一个整数数组nums和一个整数目标值target，请你在该数组中找出和为目标值target的那两个整数，并返回它们的数组下标。
你可以假设每种输入只会对应一个答案。但是，数组中同一个元素在答案里不能重复出现。你可以按任意顺序返回答案。
示例 1：

输入：nums = [2,7,11,15], target = 9
输出：[0,1]
解释：因为 nums[0] + nums[1] == 9 ，返回 [0, 1] 。

示例 2：

输入：nums = [3,2,4], target = 6
输出：[1,2]

方法一：字典实现哈希表

返回下标

class Solution:
	def twoSum(self, nums: List[int], target: int) -> List[int]:
		record = {}
		for idx, val in enumerate(nums):
			if target - val not in record:
				record[val] = idx
			else:
				return [record[target - val], idx]

返回值

class Solution:
	def twoSum(self, nums: List[int], target: int) -> List[int]:
		record = {}
		for idx, val in enumerate(nums):
			if target - val not in record:
				record[val] = idx
			else:
				return [target - val, val]

复杂度分析：

时间复杂度： $O (N)$ ，其中 N 是数组中的元素数量。对于每一个元素 x，我们可以 $O (1)$ 地寻找 target - x。
空间复杂度： $O (N)$ ，其中 N 是数组中的元素数量。主要为哈希表的开销。

方法二：暴力

class Solution(object):
    def twoSum(self, nums, target):
        n = len(nums)
        for i in range(n):
            for j in range(i+1,n):
                if nums[i]+nums[j]==target:
                    return i,j

复杂度分析：

时间复杂度： $O(N^2)$ ，其中 NN 是数组中的元素数量。最坏情况下数组中任意两个数都要被匹配一次。

空间复杂度： $O (1)$ 。

88.合并两个有序数组

https://leetcode.cn/problems/merge-sorted-array/
数组双指针排序

给你两个按非递减顺序排列的整数数组nums1和nums2，另有两个整数m和n，分别表示nums1和nums2中的元素数目。
请你合并nums2 到 nums1 中，使合并后的数组同样按非递减顺序排列。
注意：最终，合并后数组不应由函数返回，而是存储在数组nums1中。为了应对这种情况，nums1 的初始长度为 m + n，其中前 m 个元素表示应合并的元素，后 n 个元素为 0 ，应忽略。nums2 的长度为 n 。

题目分析：不同于合并有序链表，题目中说明要直接在nums1上修改，因此不能开辟一个新的空数组不断append那种经典的做法。

方法一：直接合并后排序

最直观的方法是先将数组 $nums2\textit{nums}_2$ 放进数组 $nums1\textit{nums}_1$ 的尾部，然后直接对整个数组进行排序。

class Solution:
    def merge(self, nums1: List[int], m: int, nums2: List[int], n: int) -> None:
        """
        Do not return anything, modify nums1 in-place instead.
        """
        nums1[m:] = nums2
        nums1.sort()

复杂度分析

时间复杂度： $O((m+n)log⁡(m+n))O((m+n)\log(m+n))$ 。
排序序列长度为 $m + n$ ，套用快速排序的时间复杂度即可，平均情况为 $O((m+n)log⁡(m+n))O((m+n)\log(m+n))$ 。
空间复杂度： $O(log⁡(m+n))O(\log(m+n))$ 。
排序序列长度为 $m + n$ ，套用快速排序的空间复杂度即可，平均情况为 $O(log⁡(m+n))O(\log(m+n))$ 。

方法二：双指针

思路：利用数组 $nums1\textit{nums}_1$ 与 $nums2\textit{nums}_2$ 已经被排序的性质。
为了利用这一性质，我们可以使用双指针方法。这一方法将两个数组看作队列，每次从两个数组头部取出比较小的数字放到结果中。为两个数组分别设置一个指针 $p_1$ 与 $p_2$ 来作为队列的头部指针。

tips：除了对比大小，还要考虑到p1=m和p2=n的情况，分情况讨论。

class Solution:
    def merge(self, nums1: List[int], m: int, nums2: List[int], n: int) -> None:
        """
        Do not return anything, modify nums1 in-place instead.
        """
        # 双指针
        sorted = []
        p1 , p2 = 0, 0
        while p1 < m or p2 < n:
            if p1 == m:
                sorted.append(nums2[p2])
                p2 += 1
            elif p2 == n:
                sorted.append(nums1[p1])
                p1 += 1
            elif nums1[p1] < nums2[p2]:
                sorted.append(nums1[p1])
                p1 += 1
            else:
                sorted.append(nums2[p2])
                p2 += 1
        nums1[:] = sorted