算法突击啊

入门

判断数组存在重复元素

# 思路1：排序
nums = sorted(nums)
n = len(nums)
#相邻元素一定相同
for i in range(1,n):
	if nums[i] == nums[n-1]:
		return True
return False

#思路2：哈希表：记录元素的个数
dic = {}
for i in range(len(nums)):
	if dic.get(nums[i]):
		return True
	dic[nums[i]] = 1
return False

# 思路3: 集合set
if len(set(nums)) == len(nums):
	return True
return False

最大字序和

# 思路1: 暴力解法（容易超出时间限制）
n = len(nums)
max = nums[0]
 if n == 1:
     return nums[0]
 for i in range(n):
     for j in range(i,n):
         s = sum(nums[i:j+1])
         if s > max:
             max = s
 return max
# 思路2：动态规划
# 包括下标i之前的最大连续子序列和为dp[i]
# 状态转移方程dp[i] = max(dp[i-1]+nums[i],nums[i])
for i in range(1,len(nums)):
    nums[i] = max(nums[i-1]+nums[i],nums[i])
return max(nums)

两数之和

#思路1：暴力解法
# 获取列表特定元素的下标 nums.index(key)
 n = len(nums)
 for i in range(n):
    key = target-nums[i]
    if key in nums and nums.index(key)!=i:
        return [i,nums.index(key)]
# 思路2：哈希表
# enumerate函数的使用
hashtable = dict()
for i, num in enumerate(nums):
    if target - num in hashtable:
        return [hashtable[target - num], i]
    hashtable[nums[i]] = i
return []

# enumerate()函数的使用
# 既要遍历索引又要遍历元素
for index,item in enumerate(list1):
	print(index,item)
# 还可指定索引起始值
for index,item in enumerate(list1,start):
	print(index,item)
	

合并两个有序数组

# 思路1：先合并数组，在排序
nums1[m:] = nums2
return nums1.sort()
# 思路2：双向指针
sorted = []
p,q = 0,0
while p<m and q <n:
    if nums1[p] <= nums2[q]:
        sorted.append(nums1[p])
        p += 1
    else:
        sorted.append(nums2[q])
        q += 1
if p == m and q<n:
    while q<n:
        sorted.append(nums2[q])
        q+= 1
else:
    while p<m:
        sorted.append(nums1[p])
        p += 1
nums1[:] = sorted
return nums1

两个列表的交集

# 思路1：哈希表  Counter的使用
def intersect(self, nums1, nums2):
    nums1 = Counter(nums1)
    res = []
    for i in nums2:
        if i in nums1 and nums1[i]:
            res.append(i)
            nums1[i] -= 1
    return res
# 思路2：先排序然后双指针
def intersect(self, nums1, nums2):
    nums1, nums2 = sorted(nums1), sorted(nums2)
    l1, l2 = 0, 0
    res = []
    while l1 < len(nums1) and l2 < len(nums2):
        if nums1[l1] == nums2[l2]:
            res.append(nums1[l1])
            l1 += 1
            l2 += 1
        elif nums1[l1] < nums2[l2]:
            l1 += 1
        else:
            l2 += 1
    return res

买卖股票的最佳时机

# 思路1：暴力解法（超时）
def maxProfit(self, prices):
    """
    :type prices: List[int]
    :rtype: int
    """
    res = 0 
    for i in range(len(prices)):
        for j in range(i+1,len(prices)):
            res = max(res,prices[j]-prices[i])
    return res
# 思路2：一次遍历
def maxProfit(self, prices):
   inf = int(1e9)
   minprice = inf
   maxprofit = 0
   for price in prices:
       maxprofit = max(price - minprice, maxprofit)
       minprice = min(price, minprice)
   return maxprofit

杨辉三角

class Solution(object):
    def generate(self, numRows):
        """
        :type numRows: int
        :rtype: List[List[int]]
        """
        res = []
        pre = []
        for i in range(numRows):
            temp = [1]*(i+1)
            if i>=2:
                for n in range(1,i):
                    temp[n] = pre[n-1] + pre[n]
            res += [temp]
            pre = temp
        return res

字符串中的第一个唯一字符(collection使用）

class Solution(object):
    def firstUniqChar(self, s):
        """
        :type s: str
        :rtype: int
        """
        frequency = collections.Counter(s)
        for i, ch in enumerate(s):
            if frequency[ch] == 1:
                return i
        return -1

collections包的使用方法