leetcode-刷题日记（包括思路整理和学习大佬们的算法）-[代码同步更新到Github]
leetcode 每日一题Github地址
主要一方面是为了督促自己刷题，另一方便在刷题过程中学习大佬们的解题思路并整理下来。
GitHub主页：https://github.com/zht2649825643
day1 -买卖股票的最佳时机 II
day2 -存在重复元素
day3 -只出现一次的数字
day4 -两个数组的交集 II
day5 -加一
第一天 -买卖股票的最佳时机 II
给定一个数组，它的第 i 个元素是一支给定股票第 i 天的价格。
设计一个算法来计算你所能获取的最大利润。你可以尽可能地完成更多的交易（多次买卖一支股票）。
注意：你不能同时参与多笔交易（你必须在再次购买前出售掉之前的股票）。
示例一
输入: [7,1,5,3,6,4]
输出: 7
解释: 在第 2 天（股票价格 = 1）的时候买入，在第 3 天（股票价格 = 5）的时候卖出, 这笔交易所能获得利润 = 5-1 = 4 。
随后，在第 4 天（股票价格 = 3）的时候买入，在第 5 天（股票价格 = 6）的时候卖出, 这笔交易所能获得利润 = 6-3 = 3 。
示例二
输入: [1,2,3,4,5]
输出: 4
解释: 在第 1 天（股票价格 = 1）的时候买入，在第 5 天 （股票价格 = 5）的时候卖出, 这笔交易所能获得利润 = 5-1 = 4 。
注意你不能在第 1 天和第 2 天接连购买股票，之后再将它们卖出。
因为这样属于同时参与了多笔交易，你必须在再次购买前出售掉之前的股票。
def maxProfit(self, prices: List[int]) -> int:
"""
LeeTCode：自己的方案
思路：想要获利肯定后一天要比前一天收入多。
执行用时：76 ms
内存消耗：15 MB
"""
profit = 0
if len(prices) == 0:
return 0
for i in range(len(prices)-1):
if prices[i] < prices[i+1]:
profit += (prices[i+1] - prices[i])
pass
return profit
解题思路：
这里我们可以采用贪心策略来解决：首先我们需要理解一点，第i天买入，第j天卖出得到的收益和第i天买入，第i+p天卖出，第i+p+1
天再买入，第j天卖出得到的收益是相同的。比如[1,2,3,4,5]，很明显我们知道最大收益是4，可以看作是第一天买入，第五天卖出，
但是也可以看作是第1天买入，第二天卖出，同时买入，第三天又卖出，同时买入······
第二天 -存在重复元素
给定一个整数数组，判断是否存在重复元素。
如果任意一值在数组中出现至少两次，函数返回 true 。如果数组中每个元素都不相同，则返回 false 。
示例1
输入: [1,2,3,1]
输出: true
示例2
输入: [1,1,1,3,3,4,3,2,4,2]
输出: true
示例3
输入: [1,2,3,4]
输出: false
def containsDuplicate(self, nums: List[int]) -> bool:
"""
LeeTCode：自己的方案
思路：先排序，排序后重复元素相邻。
执行用时：56 ms
内存消耗：16.9 MB
"""
nums.sort()
for i in range(1, len(nums)):
if nums[i] == nums[i-1]:
return True
return False
解题思路：
一： 将无序数组先进行排序，然后判断是否有连续的数字。
二： 使用python的元组数据结构进行判断。（元组中不能出现重复的数据）
第三天 -只出现一次的数字
给定一个非空整数数组，除了某个元素只出现一次以外，其余每个元素均出现两次。找出那个只出现了一次的元素。
说明：
你的算法应该具有线性时间复杂度。 你可以不使用额外空间来实现吗？
示例1
输入: [1,2,2,1,3]
输出: 3
示例2
输入: [1,2,2]
输出: 1
示例3
输入: [4,1,2,1,2]
输出: 4
def singleNumber(self, nums: List[int]) -> int:
nums.sort()
lens = len(nums)
if lens == 1:
return nums[0]
if nums[1] != nums[0]:
return nums[0]
for i in range(1, lens, 2):
if nums[i] != nums[i-1]:
return nums[i-1]
return nums[lens-1]
解题思路：
一： 将无序数组先进行排序，然后判断是否有连续的数字,在遍历数组时一次进两位。
二： 使用python的异或运算。（0^num = num / num ^ num = 0 /n ^ m = m -n）
第四天 -两个数组的交集 II
给定两个数组，编写一个函数来计算它们的交集。
说明：
输出结果中每个元素出现的次数，应与元素在两个数组中出现的次数一致。
我们可以不考虑输出结果的顺序。
进阶:
如果给定的数组已经排好序呢？你将如何优化你的算法？
如果 nums1 的大小比 nums2 小很多，哪种方法更优？
如果 nums2 的元素存储在磁盘上，磁盘内存是有限的，并且你不能一次加载所有的元素到内存中，你该怎么办？
示例1
输入: nums1 = [1,2,2,1], nums2 = [2,2]
输出: [2,2]
示例2
输入: nums1 = [4,9,5], nums2 = [9,4,9,8,4]
输出: [4,9]
def intersect(self, nums1: List[int], nums2: List[int]) -> List[int]:
list_add = []
num1 = set(nums1)
num2 = set(nums2)
for i in num1:
if i in num2:
count = min(nums1.count(i), nums2.count(i))
for j in range(count):
list_add.append(i)
return list_add
解题思路：
一： 将无序数组先进行排序，然后逐个判断是左右数组的大小，从而找到相同的值。
二： 使用python的元组数据结构进行判断，利用元组结构找出重复的值，再用列表统计值的个数。（元组中不能出现重复的数据）
第五天 -加一
给定一个由整数组成的非空数组所表示的非负整数，在该数的基础上加一。
最高位数字存放在数组的首位， 数组中每个元素只存储单个数字。
你可以假设除了整数 0 之外，这个整数不会以零开头。
示例1
输入: [1,2,3]
输出: [1,2,4]
解释: 输入数组表示数字 123。
示例2
输入: [4,3,2,1]
输出: [4,3,2,2]
解释: 输入数组表示数字 4321。
def plusOne(self, digits: List[int]) -> List[int]:
"""
LeeTCode：自己的方案
思路：将列表转为整型数字，然后加一在转会列表。
执行用时：36 ms
内存消耗：13.9 MB
"""
lens = len(digits)
data = []
num = 0
for i in range(lens):
num = (num * 10) + digits[i]
num += 1
while num != 0:
data.append(num % 10)
num = num // 10
data.reverse()
return data
解题思路：
一：
二：
第六天 -移动零
给定一个数组 nums，编写一个函数将所有 0 移动到数组的末尾，同时保持非零元素的相对顺序。
示例1
输入: [0,1,0,3,12]
输出: [1,3,12,0,0]
def plusOne(self, digits: List[int]) -> List[int]:
"""
LeeTCode：自己的方案
思路：将列表转为整型数字，然后加一在转会列表。
执行用时：36 ms
内存消耗：13.9 MB
"""
lens = len(digits)
data = []
num = 0
for i in range(lens):
num = (num * 10) + digits[i]
num += 1
while num != 0:
data.append(num % 10)
num = num // 10
data.reverse()
return data
解题思路：
一：
二：