题1（简单）.
思路：
因为时间复杂度小于n^2,所以不能双for遍历，怎么优化？
这里采用一个键值对的形式，存储nums离target的间隔和它的下标，只要n，然后再遍历nums有没有刚好是这个距离的就好了，只要注意两相同的数字这种情况就好了
python3代码
class Solution:
def twoSum(self, nums: List[int], target: int) -> List[int]:
need={}
for i in range(0,len(nums)):
a=target-nums[i]
need[a]=i
for i in range(0,len(nums)):
if(need.get(nums[i],'')!='' and need.get(nums[i],'')!=i):
return [i,need[nums[i]]]题2（中等）：
思路：
无非就是设置一个进位标志就好了，但是呢，这个东西的python，我没看懂它的参数是啥东西，所以用c++，
c++代码
ListNode* addTwoNumbers(ListNode* l1, ListNode* l2) {
ListNode* head;
ListNode* tail;
int flag=0;
for(int i=0;;i++){
int val1=(l1==NULL)?0:l1->val;
int val2=(l2==NULL)?0:l2->val;
int sum=(val1+val2+flag)%10;
flag=(val1+val2+flag)/10;
ListNode* newNode=new ListNode(sum);
if(i==0){
head=newNode;
tail=newNode;
}
else{
tail->next=newNode;
tail=tail->next;
}
if(l1!=NULL) {l1=l1->next;}
if(l2!=NULL) {l2=l2->next;}
if(l1==NULL&&l2==NULL&&flag==0){
break;
}
}
return head;
}题3（中等）：
思路：
我们可以用一个字符串来接受子串，如果发现有重复字符就统计长度再切割前面的
python3代码
class Solution:
def lengthOfLongestSubstring(self, s: str) -> int:
n=[]
ss=''
for i in range(len(s)):
if s[i] not in ss:
ss+=s[i]
else:
n.append(len(ss))
ss=ss.split(s[i])[-1]+s[i]
n.append(len(ss))
return max(n)题4（困难）：
思路：
找两数组中位数，这个看起来简单，顺手反应就是数第(m+n)/2个，这个难在要求时间复杂度为log(m+n)，所以不能这样搞，我的思路是：每次切割长度为较小长度的一半，然后比较哪个对中位数没有影响就切哪个
python代码
def findMedianSortedArrays(self, nums1: List[int], nums2: List[int]) -> float:
med=None
while 1:
if len(nums1) == 0:
med2 = nums2[(len(nums2)) // 2] if len(nums2) % 2 == 1 else (nums2[len(nums2) // 2 - 1] + nums2[
len(nums2) // 2]) / 2
med = med2
break
if len(nums2) == 0:
med1 = nums1[(len(nums1)) // 2] if len(nums1) % 2 == 1 else (nums1[len(nums1) // 2 - 1] + nums1[
len(nums1) // 2]) / 2
med = med1
break
if (len(nums1) + len(nums2) <= 2):
med = ((nums1[0] if len(nums1) > 0 else 0) + (nums2[0] if len(nums2) > 0 else 0)) / (len(nums1) + len(nums2))
break
cutlen=len(nums1)//2 if len(nums1)<=len(nums2) else len(nums2)//2
if(cutlen<1):
cutlen=1
if nums1[cutlen-1]<nums2[cutlen-1]:
nums1=nums1[cutlen:]
else:
nums2=nums2[cutlen:]
if len(nums1)!=0 and (len(nums2)==0 or nums1[len(nums1)-cutlen]>nums2[len(nums2)-cutlen]) :
nums1=nums1[:len(nums1)-cutlen]
else:
nums2=nums2[:len(nums2)-cutlen]
return med题5（中等）：
思路：
第一步，统计所有回文可能的起点
python代码：
def longestPalindrome(self, s: str) -> str:
if len(s)==0 or len(s)==1:
return s
#第一步，统计所有回文可能的起点
p_start=[]
#p_start里面含有[左值，右值，长度]
for i in range(len(s)-1):
if s[i]==s[i+1]:
p_start.append({'left':i,'right':i+1,'length':2})
if i-1>=0 and i+1<len(s) and s[i-1]==s[i+1]:
p_start.append({'left':i-1,'right':i+1,'length':3})
for p in p_start:
while 1:
if p['left']-1>=0 and p['right']+1<len(s) and s[p['left']-1]==s[p['right']+1]:
p['left']-=1
p['right']+=1
p['length']+=2
else:
break
res_len=0
res=0
for i in range(len(p_start)):
res_len,res=(p_start[i]['length'],i) if p_start[i]['length']>res_len else (res_len,res)
return s[p_start[res]['left']:p_start[res]['right']+1] if len(p_start)!=0 else s[0]
题6（中等）：
思路：
这个相较于前面只能是简单，个人认为，会print打印菱形都能搞这个，直接设置一个2阶数组就好了，只要注意位置变化就好了
python代码：
def convert(self, s: str, numRows: int) -> str:
#创建n堆空字符串
new_list=['' for i in range(numRows)]
#遍历字符串
k=0
flag=1
for i in range(len(s)):
new_list[k]+=s[i]
k+=flag
if numRows-1==0:
k=0
else:
if k==0:
flag=1
elif k==numRows-1:
flag=-1
return ''.join(new_list)
题7（中等）：
思路：
怎么感觉难度降下来了，这个用python太容易了啊，用c++应该也不难吧，翻转字符串一个栈不就好了吗？
python代码：
class Solution:
def reverse(self, x: int) -> int:
x_str=str(x)
if x_str[0]=='-':
x_str='-'+x_str[:0:-1]
else:
x_str=x_str[::-1]
i=int(x_str) if int(x_str)>=-2**31 and int(x_str)<= 2**31-1 else 0
return i
题8（中等）：
思路：
这个截断和我想的截断有点不同啊，我以为还要转二进制然后断呢
python代码：
class Solution:
def myAtoi(self, s: str) -> int:
s=s.strip()
s_num=''
for i in range(len(s)):
if i==0 and (s[i]=='+' or s[i]=='-'):
s_num+=s[i]
continue
if ord(s[i])>=ord('0') and ord(s[i])<=ord('9'):
s_num+=s[i]
continue
else:
break
if s_num=='+' or s_num=='-':
s_num=0
s_num=int(s_num if s_num!='' else 0)
if s_num<=-2**31:
s_num=-2**31
if s_num>=2**31-1:
s_num=2**31-1
return s_num
题9（简单）：
思路：
这个对于python有点过于简单了吧
python代码：
class Solution:
def isPalindrome(self, x: int) -> bool:
return str(x)==str(x)[::-1]
题10（困难）：
思路：
我只能说我不是理解正则，毕竟爬虫我都不管啥，直接.*？,导致我理解错了题意思，我当时以为*是可以匹配任意了，然后写一晚上都没成功，看评论才理解意思，其实理解了写起来就清晰了，采用的方法是递归，时间比较消耗，所以要预处理一下，不然超时
python代码：
class Solution:
def isMatch(self, s: str, p: str) -> bool:
if p=='':
return s==''
if s=='':
if len(p)!=2 and p[1]!='*':
return False
if len(p)==2 and p[1]=='*':
return True
i=0
#预处理，
while 1:
if p[i]=='*':
if i+2<len(p) and p[i+2]=='*':
if p[i-1]==p[i+1]:
p=p[:i+1]+p[i+3:]
i+=1
if i>=len(p):
break
s_p=0
p_p=0
while 1:
if s_p>=len(s) and p_p>=len(p):
return True
if p_p>=len(p):
return False
if p_p+1<=len(p)-1 and p[p_p+1]=='*':
for i in range(s_p,len(s)):
if s[i]!=p[p_p] and p[p_p]!='.':
break
else:
if self.isMatch(s[i:],p[p_p]+p[p_p+2:]):
return True
p_p+=2
else:
if s_p>=len(s):
return False
if p[p_p]==s[s_p] or p[p_p]=='.':
p_p+=1
s_p+=1
else:
return False
写得很气，所以赶工，注释都没有，再看的话又烦，感觉屎山一样，做的最久的一次，写了3个版本的代码