leetcode 刷题记录

（1）2019.10.11 day1

两数之和

1. 获得数组元素个数 len(list)即可。
2. 出现 expected an indented block错误，是缩进出错。
3. 数组取其元素是;ist[i]，用方括号。
4. 第一次用leetcode，给好了格式，只要在类里面把函数补充完整就行了。
5. 我是写了两个循环，遍历去找和为target的两个数，时间消耗太大了。时间是0(n^2)
6. 以空间换时间，利用哈希表可以把时间缩为0(n）先用enumerate(可迭代对象)，得到数据和对应下标，然后通过for循环取出其中的序列，存在字典中，这样就可以快速拿到值了。

（2）2019.10.12 day2

删除排序数组中的重复项

1.colon是冒号,indent是缩进；
2.python还是很不熟练阿，python中没有end 老是和matlab混淆
3.没有考虑数组是空的或者只有一个数的情况，可以单独用if语句先排除掉
4.没有考虑清楚边界问题，数组下标每次移动后都要判断是否除了边界。

（3）2019.10.13 day3

移除元素

1.跟上一题一样阿，快慢指针，没得问题。
2.看了题解，发现可以倒叙删减 range(j,-1,-1) 然后发现相同的元素用数组的pop(i)，不影响前面的元素，后面的元素一起前移。
3.感觉用filter函数过滤也可以达到同样的效果，就是不能原地删除了，但是感觉很简单。

（4）2019.10.14 day4

搜索插入位置

1.用暴力查找，o(n)，用二分查找，平均是o(nlogn)
2.没有python一行解决不了的问题，哈哈哈哈，正好用到了之前看到的列表生成器，将比target小的部分筛选出来，求该部分数组长度，位置即可找到，这种方法的速度和暴力搜索差不多，但是一行就能表示，十分简洁。
len([a for a in nums if a <target])
3. mid=int((i+j)/2)
while (i<=j):
if target==nums[mid]:
return mid
elif target<nums[mid]:
j=mid-1
mid=int((i+j)/2)
elif target>nums[mid]:
i=mid+1
mid=int((i+j)/2)

（5）2019.10.15 day5

最大子序和

1.因为是连续的，可以从头不断遍历，用一个值记录到当前位置的最大子序和，然后计算下一个的时候，若上一个子序和为负则直接舍弃。
2.分治法的话，就是从中间分成左右两半，左右递归计算，若子序和片段经过中心另外计算。

（6）2019.10.16 day6

加一

1.range( , , )始终记得左闭右开，不管是递增还是递减
2.不能老是用while，用for循环，然后不满足条件的break就行了。

（7）2019.10.17 day7 补

合并两个有序数组

1.可以直接把两个数组放在一起，重新排序
2.设置两个指针，分别从两个数组头开始比较，放在一个新的数组中。这样就是简单的o(n)，遍历一遍即可。
3.边界情况要好好考虑怎么写，是用while还是for循环

（8）2019.10.18 day8 补

杨辉三角1

列表的初始化
1.

a=range(10) # a就是range类型，可迭代，但不是列表
b=[i for i in range(10)] ## 用列表生成式子很好用，可以生成列表，还可以加条件
c=list(range(10))  #可以返回一个列表 注意要用小括号才行
d=list[range(10)]  #注意列表中括号里面只能放下标

2.杨辉三角的每一个位置都是可以用组合数公式得到的。
（从0行开始）第k行的数为：Cko,Ck1……Ckk

（9）2019.10.19 day9 补

杨辉三角2

1.为了减少空间复杂度，可以用一个数组单独的记录上一条内容，然后不断更新。

（10）2019.10.20 day10 补

买卖股票的最佳时机1

1.算每个数之前数的最小值时，要考虑到前一个数的之前的最小值也可以利用，这样就可以利用之前的算过的内容，减少计算量。
2.注意给空数组的情况

（11）2019.10.21 day11 补

买卖股票的最佳时机2

1.可以通过观察数值的图像变化，更好的理解题目。得到只要是处于递增情况，就可以利用最高的减去最低的，加起来即可。

（12）2019.10.22 day12 补

两数之和2

1.还是用的哈希函数的方式，边存入字典，边判断是否存在符合两数之和的数。

class Solution:
    def twoSum(self, numbers, target):
        a={}
        for i,j in enumerate(numbers):
            a.update({j:i}) #更新字典方式
        for i in range(0,len(numbers)):
            if a.get(target-numbers[i])!=None:
                return [i+1,a.get(target-numbers[i])+1]

        return []

（13）2019.10.23 day13 补

求众数

1.我还是用的存字典的方法，每存一个数就知道这个数此时的次数了，这样就O（n）
2.求众数吗，那这个数最少出现了n/2次，所以不管左右的滑动，排序之后，最中间的那个数肯定数属于众数。

（14）2019.10.24 day14

（15）2019.10.25 day15

（16）2019.10.26 day16

（17）2019.10.27 day17

（18）2019.10.28 day18

旋转数组

1.遍历每一个数，用公式计算出对应下标，然后直接赋值给新的数组，最后替换。为了使用原地算法，直接用一个变量保存当前数组需要被替换的数，然后替换之后，寻找到该数的家即可。循环n次。
2.每次全部移一位，移K次。这样只用空间复杂度O（1）.但是也太耗时了。
3.肯定是左边一部分，喀一下子移到右边去了。算清楚从哪个地方开始的就好了。空间复杂度为O1，也就是不需要多于的数据结构辅助，直接在原来的输入上进行覆盖。算出来k%长度也就是要移动的距离了
4.可以先反转整体，再前半部分反转，后半部分反转。
5.那个循环替换的啊要就算出循环的次数再换下一个。这个确实没发现规律刚开始。

（19）2019.11.11 day

存在重复元素

1.用字典哈希存储，遍历判断，非常常见。
2.一句话解决：

return len(nums)!=len(set(nums)) #set是生成对应集合，没有重复的元素。

（20）2019.11.12 day

存在重复元素2

1.感觉这题，题目问的很有问题。应该是存在一组下标使数值相等，并且下标之差小于等于k即可。
2.不断更新，寻找比k小的即可。若同一数值的两个下标相减大于k，为了保证后面的可能出现更小间隔，应该用后面的下标进行更新。