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

第一天

217.存在重复元素

https://leetcode.cn/problems/contains-duplicate/
数组 哈希表 排序
给你一个整数数组 nums 。如果任一值在数组中出现至少两次 ，返回 true ；如果数组中每个元素互不相同，返回 false 。

方法一：dict()

思路：快递检索数据，用哈希表。python可以用字典来实现哈希表。
循环遍历数组，并将数组元素存储在字典中，判断是否存在相同元素，存在则返回True；若循环结束，不存在相同元素，则返回False；

from typing import List

class Solution:
	def containsDuplicate(self, nums: List[int]) -> bool:
		record = {}     # records = dict()    {1:0,3:1,4:2}
		for idx, val in enumerate(nums):   
			if val not in record:     #  指的是键值，相当于records.keys()
				record[val] = idx
			else:
				return True
		return False
		
if __name__ == '__main__':
    nums = [1,3,4,3,2,4,2]
    so = Solution()
    print(so.containsDuplicate(nums))

用判断值的方法，为什么会超出时间限制？

class Solution:
   def containsDuplicate(self, nums: List[int]) -> bool:
   	record = {}     
   	for idx, val in enumerate(nums):   
   		if val not in record.values():
   			record[idx] = val 
   		else:
   			return True
   	return False

方法二：set()

set() 函数创建一个无序不重复元素集

class Solution:
	def containsDuplicate(self, nums: List[int]) -> bool:
		record = set()     
		for num in nums:   
			if num in record:
				return True
			else:
				record.add(num)
		return False

方法三：暴力排序

class Solution:
	def containsDuplicate(self, nums: List[int]) -> bool:
		nums.sort()
		for i in range(len(nums) - 1):
			if nums[i] == nums[i+1]:
				return True
		return False

---

53.最大子数组和

https://leetcode.cn/problems/maximum-subarray/
数组 分治 动态规划
给你一个整数数组nums，请你找出一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和。 子数组是数组中的一个连续部分。

方法一：动态规划

• 初始化：$dp[0]=nums[0]$
• 取当前元素之前的和的最大值：$preSum=max(preSum+nums[i],nums[i])$
• 状态转移方程：
  $$dp[i]=max(dp[i-1],preSum)$$

class Solution:
    def maxSubArray(self, nums: List[int]) -> int:
        # 动态规划思想
        # 初始化
        dp = [0] * len(nums)
        dp[0] = nums[0]    # 考虑len(nums)为1时，值为nums[0]
        preSum = nums[0]

        # 递推公式
        for i in range(1, len(nums)):
            preSum = max(preSum + nums[i], nums[i])
            dp[i] = max(dp[i - 1], preSum)
        return dp[-1]   # 等价于dp[len(nums)-1]

方法二：动态规划_优化

创建一个数组用来存储子数组的和，取最大值。
dp[i-1]是到前一项为止的最大子序和，如果dp[i-1]大于0，则下一个子数组和是dp[i]和dp[i-1]相加，否则就是dp[i]本身。

class Solution:
	def maxSubArray(self, nums: List[int]) -> int:
		dp = nums
		for i in range(1, len(nums)):
			dp[i] = dp[i] + max(dp[i-1], 0)
		return max(dp)