Two Sum
两数==target
方法二更好
题1，对时间复杂度有要求O(n)，所以维护一个字典，遍历过的数值放在字典中，直接遍历时候查找字典中有没有出现差，查找字典时间复杂度是O(1)，所以O(n)*O(1) = O(n)，满足要求。
nums = [0, 1, 2, 7, 11, 15]
target = 9
def chek(nums, target):
dict1 = {}
for i, ele in enumerate(nums):
if (target-ele) in dict1:
return dict1[target-ele], i
else:
dict1[ele] = i
print(chek(nums, target))
下面方法和上面方法一样，但是内存稍稍省下0.1M
class Solution(object):
def twoSum(self, nums, target):
"""
:type nums: List[int]
:type target: int
:rtype: List[int]
"""
dict = {}
for i in range(len(nums)):
if dict.get(target-nums[i]) == None:
dict[nums[i]] = i
else:
return dict[target-nums[i]], i
方法二，不用维护一个字典的开销
class Solution(object):
def twoSum(self, nums, target):
"""
:type nums: List[int]
:type target: int
:rtype: List[int]
"""
for i in range(len(nums)):
if (target-nums[i]) in nums[i+1:]:
# 这里返回加i+1是因为nums[i+1:]计数又是从0开始了
return i, nums[i+1:].index(target-nums[i])+i+1
感觉方法二的if ele in list的时间复杂度就是O(n),所以不对，这道题应该是需要维护哈希表。
2. Add Two Numbers
题2，Input: (2 -> 4 -> 3) + (5 -> 6 -> 4)
Output: 7 -> 0 -> 8
Explanation: 342 + 465 = 807.
# Definition for singly-linked list.
# class ListNode(object):
# def __init__(self, x):
# self.val = x
# self.next = None
# 基本思路是两个单项列表先取数字，然后求和，再放入向列表中。还记得单项列表的构建方法吧
class Solution(object):
def addTwoNumbers(self, l1, l2):
"""
:type l1: ListNode
:type l2: ListNode
:rtype: ListNode
"""
cur = l1
sum = 0
idx = 0
while cur:
sum += cur.val*(10**idx)
cur = cur.next
idx += 1
cur = l2
idx = 0
while cur:
sum += cur.val*(10**idx)
cur = cur.next
idx += 1
if sum == 0:
return ListNode(0)
else:
self.head = ListNode(sum%10)
cur = self.head
sum //= 10
while sum > 0:
cur.next = ListNode(sum%10)
cur = cur.next
sum //= 10
return self.head
Longest Substring Without Repeating Characters
题3，
#基本思路是维护left和right两个指针，max_num，
#一个集合，先移动右指针，不在集合中则加入集合里，
#否则移动左指针，并右指针=左指针。
#用集合是因为集合的查询速度是o(1)!!
class Solution(object):
def lengthOfLongestSubstring(self, s):
"""
:type s: str
:rtype: int
"""
l = r = 0; set1= set()
max = 0
while r < len(s) and r < len(s):
if not s[r] in set1:
set1.add(s[r])
r += 1
if max < len(set1):
max = len(set1)
else:
l += 1
r = l
set1 = set()
return max
Median of Two Sorted Arrays
题4， The overall run time complexity should be O(log (m+n))我并没有注意到这句话，但是结果竟然通过了。我自算的时间复杂度应该是 O( (m+n)log(m+n) )+ O(m).
class Solution:
def findMedianSortedArrays(self, nums1: List[int], nums2: List[int]) -> float:
nums1.extend(nums2)
nums1.sort()
if not len(nums1)%2:
n = len(nums1)//2
return (nums1[n-1]+nums1[n])/2
else:
return nums1[len(nums1)//2]
Longest Palindromic Substring
用的是马拉车算法，原理链接
class Solution:
def longestPalindrome(self, s: str) -> str:
if len(s) == 1:
return s
b = "$#"
for i in s:
b += i
b += "#"
maxr = 0;idx = -1
for i in range(3,len(b)):
r = 1
while (i+r)=0:
if b[i-r] == b[i+r]:
r += 1
else:
break
(maxr,idx) = (r,i) if maxr<=r else (maxr,idx)
# 起点, 最大长度
# (idx-maxr)//2, axr-1
return s[(idx-maxr)//2: (idx-maxr)//2 + maxr-1]
ZigZag Conversion
我用的方法时间超出限制，我分别考虑了头、中、尾三种情况，需要改进算法。
class Solution:
def convert(self, s: str, numRows: int) -> str:
a = ""
gap = (numRows-2)*2+2
for i in range(numRows):
# 头情况
if i == 0:
n = 0
while n*gap < len(s):
a += s[n*gap]
n += 1
# 中间的情况
if i>0 and i
n = 1
a += s[i]
while n*gap+i < len(s) or n*gap-i < len(s):
if n*gap-i < len(s):
a += s[n*gap-i]
if n*gap+i < len(s):
a += s[n*gap+i]
n += 1
# 尾情况
if i == numRows-1:
bg = numRows-1
n = 0
while n*gap+bg < len(s):
a += s[n*gap+bg]
n += 1
return a
上面方法耗时超限制，改进思路，按照遍历放入的思想来实现。代码，核心思想是控制向下走或者向上走，然后放入对应的行。
s = "PAYPALISHIRING"
class Solution:
def convert(self, s: str, numRows: int) -> str:
if numRows == 1:
return s
s1 = [''] * numRows
dir = 1
countn = 0
for i in range(len(s)):
if countn == 0:
s1[countn] += s[i]
dir = 1
countn += dir
elif countn == numRows-1:
s1[countn] += s[i]
dir = -1
countn += dir
else:
s1[countn] += s[i]
countn += dir
return "".join(s1)
solu = Solution()
s1 = solu.convert(s, 3)
print(s)
print(s1)
改进后通过，内存消耗控制很好。运行速度到112ms。
更近一步：
思考用列表[] .append()的方法可能会提高计算速度，
class Solution:
def convert(self, s: str, numRows: int) -> str:
if numRows == 1:
return s
s1 = []
for i in range(numRows):
s1.append([])
dir = 1
countn = 0
for i in range(len(s)):
if countn == 0:
s1[countn].append(s[i])
dir = 1
countn += dir
elif countn == numRows-1:
s1[countn].append(s[i])
dir = -1
countn += dir
else:
s1[countn].append(s[i])
countn += dir
return "".join(j for i in s1 for j in i)
结论：果然[].append(“str_”)的效率比“”+str_效率高，列表扩展效率比字符串扩展效率高。运行耗时提高到100ms
下面在上面代码基础上进行精简，减少一点内存消耗。
class Solution:
def convert(self, s: str, numRows: int) -> str:
if numRows == 1:
return s
s1 = []
for i in range(numRows):
s1.append([])
dir = 1
countn = 0
for i in range(len(s)):
s1[countn].append(s[i])
countn += dir
if countn == 0:
dir = 1
if countn == numRows-1:
dir = -1
return "".join(j for i in s1 for j in i)
整数反转
class Solution:
def reverse(self, x: int) -> int:
x = int(str(x)[::-1]) if x>=0 else -int(str(x)[1:][::-1])
if x>-2**31 and x<(2**31)-1:
return x
else:
return 0
字符串转换整数 (atoi)
#这道题应该仔细看看题目要求，实现并不难，坑很多。
#还是正则表达式来的最痛快，规则实现需要考虑的细节太多。
#代码不是我的思路，[来自](https://blog.csdn.net/coder_orz/article/details/52053932)
class Solution(object):
def myAtoi(self, str):
"""
:type str: str
:rtype: int
"""
str = str.strip()
try:
res = re.search('(^[+-]?d+)', str).group()
res = int(res)
res = res if res <= 2147483647 else 2147483647
res = res if res >= -2147483648 else -2147483648
except:
res = 0
return res
正则表达式忘了不少了， 拾起来。
9. 回文数
这道题进阶版本是不用str，可提速。
class Solution:
def isPalindrome(self, x: int) -> bool:
return x>=0 and str(x) == str(x)[::-1]
进阶版本如下，思想是把数字倒过来。
class Solution:
def isPalindrome(self, x: int) -> bool:
if x<0:return False
elif x == 0:return True
else:
temp = 0
t_x = x
while x>0:
temp = 10*temp + x%10
x //= 10
return temp == t_x
虽然内存没省，但运算速度提升了。
Regular Expression Matching
这道题属于困难，用正则模块可以实现，但是这不是本题考察目的。
class Solution:
def isMatch(self, s, p):
if not s:return False
res = re.match(p, s)
if res == None:
return False
else:
return res.group() == s
预留地
找到了思路 https://www.cnblogs.com/Jessey-Ge/p/10993447.html
Container With Most Water
左右两个游标来寻找最大的体积。哪个游标高度小就移动哪个。时间复杂度O(n)
class Solution(object):
def maxArea(self, height):
"""
:type height: List[int]
:rtype: int
"""
l = 0; r = len(height)-1
max_vol = 0
while l < r:
v= min(height[r], height[l])*(r-l)
max_vol = v if max_vol
if height[r] >= height[l]:
l += 1
else:
r -= 1
return max_vol
Integer to Roman
这道题的思想，列出罗马数字和数字的所有对应字典，搞清对应关系，做减法。是人生吗。
解法
#python2中有错误，但是python3却可以通过。
class Solution(object):
def intToRoman(self, num):
"""
:type num: int
:rtype: str
"""
dic = { "M":1000, "CM":900, "D":500, "CD":400, "C":100, "XC":90, "L":50,"XL":40, "X":10, "IX":9, "V":5,"IV":4 ,"I":1 }
ele = ""
for key,item in dic.items():
while num >= item:
num -= item
ele += key
return ele
RomanToInterger
思路：判断相邻的左边数和右边数：左边>右边，取负数，左边<右边，取正数。最后数字相加。
class Solution:无锡人流医院 http://www.wxbhnk120.com/
def romanToInt(self, s):
# dic = {"M": 1000, "CM": 900, "D": 500, "CD": 400, "C": 100, "XC": 90, "L": 50, "XL": 40, "X": 10, "IX": 9, "V": 5, "IV": 4, "I": 1}
dic = {"M": 1000, "D": 500, "C": 100, "L": 50, "X": 10, "V": 5, "I": 1}
num = 0
for i in range(len(s)-1):
temp = dic[s[i]] if dic[s[i]]>=dic[s[i+1]] else -1*dic[s[i]]
num +=temp
num += dic[s[-1]]
return num
solu = Solution()
print(solu.romanToInt("XC"))
Longest Common Prefix
这道题的解法来自网络，对min函数用法值得我学习。
最长的共同前缀，思路：找到最短的字符串，一个个字符在其他字符串中比较是不是相同，不同返回之前相同部分
class Solution(object):
def longestCommonPrefix(self, strs):
"""
:type strs: List[str]
:rtype: str
"""
shotstr = min(strs, key=len)
for i, letter in enumerate(shotstr):
for other in strs:
if other[i] == letter:
pass
else:
return shotstr[:i]
return shotstr
6.mergeTwoLlists
链表结构。leetcode链接
# Definition for singly-linked list.
# class ListNode(object):
# def __init__(self, x):
# self.val = x
# self.next = None
class Solution(object):
def mergeTwoLists(self, l1, l2):
"""
:type l1: ListNode
:type l2: ListNode
:rtype: ListNode
"""
if l1 is None or l2 is None:
return l1 or l2
if l1.val > l2.val:
l2.next = self.mergeTwoLists(l2.next, l1)
return l2
else:
l1.next = self.mergeTwoLists(l1.next, l2)
return l1
7.去除相同元素
Remove Duplicates from Sorted Array
这道题返回不正确，应该是返回不重复的列表
nums = [0,1,2,3,3,3,3,4,9]
class Solution(object):
def removeDuplicates(self, nums):
"""
:type nums: List[int]
:rtype: int
"""
if not nums:
return 0
lenResult = 0
index = 0
for i in range(1, len(nums)):
if nums[i] != nums[index]:
lenResult += 1
index = i
return lenResult+1
print(Solution().removeDuplicates(nums=nums))