LeetCode题集一
简单题
1. 两数之和
给定一个整数数组nums
和一个目标值target
请你在该数组中找出和为目标值的那两个整数,并返回他们的数组下标。
你可以假设每种输入只会对应一个答案。但是,数组中同一个元素不能使用两遍。
示例:
给定 nums = [2, 7, 11, 15], target = 9
因为 nums[0] + nums[1] = 2 + 7 = 9
所以返回 [0, 1]
解法:
原本想用列表来实现的,不过比较消耗时间,参考了大神们的答案,发现字典的速度确实是快了不少。
- 列表实现
要点: list.index()
def twoSum(nums: List[int], target: int) -> List[int]:
# 使用列表的方法
num_list = []
for i, num in enumerate(nums):
another_num = target - num
if another_num in num_list:
return [nums.index(another_num), i]
num_list.append(num)
- 字典实现
def twoSum(nums: List[int], target: int) -> List[int]:
# 使用字典 - 推荐
hashmap = {}
for index, num in enumerate(nums):
another_num = target - num
if another_num in hashmap:
return [hashmap[another_num], index]
hashmap[num] = index
return None
7. 整数反转
给出一个 32 位的有符号整数,你需要将这个整数中每位上的数字进行反转。
示例 1:
输入: 123
输出: 321
示例 2:
输入: -123
输出: -321
示例 3:
输入: 120
输出: 21
注意:
假设我们的环境只能存储得下 32 位的有符号整数,则其数值范围为 [−231, 231 − 1]。请根据这个假设,如果反转后整数溢出那么就返回 0。
python解法:
一种思路是传统的解法,除以10来获取位数。另一种解法就是使用字符串的方式,实现反转,这里主要用的是这种方法,时间48ms。
def reverse(x: int) -> int:
# 查看是否是0
if x == 0:
return 0
flag = ""
x_str = str(x)
# 确定正负数
if x_str[0] == "-":
flag = "-"
x_str = x_str.split("-")[1]
x = int(flag + x_str[::-1])
# 判断范围是否正确
if -2**31 < x < 2**31-1:
return x
return 0
9. 回文数
判断一个整数是否是回文数。回文数是指正序(从左向右)和倒序(从右向左)读都是一样的整数。
示例 1:
输入: 121
输出: true
示例 2:
输入: -121
输出: false
解释: 从左向右读, 为 -121 。 从右向左读, 为 121- 。因此它不是一个回文数。
示例 3:
输入: 10
输出: false
解释: 从右向左读, 为 01 。因此它不是一个回文数。
进阶:
你能不将整数转为字符串来解决这个问题吗?
解法:
思路:使用字符串切片来实现翻转,之后进行对比即可;不转换成字符串的话,就先计算出翻转后的数再进行对比就行了
- 转为字符串
def isPalindrome(x: int) -> bool:
if x < 0:
return False
elif x < 10:
return True
x_str = str(x)
if x_str == x_str[::-1]:
return True
return False
or
def isPalindrome(x: int) -> bool:
return str(x) == str(x)[::-1]
- 不用字符串
def isPalindrome(x: int) -> bool:
if x < 0:
return False
a, b = x, 0
while a != 0:
b = b * 10 + a % 10
a = a // 10
return b == x
13. 罗马数字转整数
罗马数字包含以下七种字符: I, V, X, L,C,D 和 M。
字符 数值
I 1
V 5
X 10
L 50
C 100
D 500
M 1000
例如, 罗马数字 2 写做 II ,即为两个并列的 1。12 写做 XII ,即为 X + II 。 27 写做 XXVII, 即为 XX + V + II 。
通常情况下,罗马数字中小的数字在大的数字的右边。但也存在特例,例如 4 不写做 IIII,而是 IV。数字 1 在数字 5 的左边,所表示的数等于大数 5 减小数 1 得到的数值 4 。同样地,数字 9 表示为 IX。这个特殊的规则只适用于以下六种情况:
- I 可以放在 V (5) 和 X (10) 的左边,来表示 4 和 9。
- X 可以放在 L (50) 和 C (100) 的左边,来表示 40 和 90。
- C 可以放在 D (500) 和 M (1000) 的左边,来表示 400 和 900。
给定一个罗马数字,将其转换成整数。输入确保在 1 到 3999 的范围内。
示例 1:
输入: "III"
输出: 3
示例 2:
输入: "IV"
输出: 4
示例 3:
输入: "IX"
输出: 9
示例 4:
输入: "LVIII"
输出: 58
解释: L = 50, V= 5, III = 3.
示例 5:
输入: "MCMXCIV"
输出: 1994
解释: M = 1000, CM = 900, XC = 90, IV = 4.
提示:
题目所给测试用例皆符合罗马数字书写规则,不会出现跨位等情况。
IC 和 IM 这样的例子并不符合题目要求,49 应该写作 XLIX,999 应该写作 CMXCIX 。
关于罗马数字的详尽书写规则,可以参考 罗马数字 - Mathematics 。
解法:
思路:特殊情况下,较小的值会在较大的值左边,所以需要减去较小的值,根据这个点入手
def romanToInt(s: str) -> int:
a = {'I':1, 'V':5, 'X':10, 'L':50, 'C':100, 'D':500, 'M':1000}
ans = 0
for i in range(len(s)):
# 左边小于右边 减去左边的值
if i < len(s)-1 and a[s[i]] < a[s[i+1]]:
ans -= a[s[i]]
# 不小于的话就是正常情况,直接加上去就行了
else:
ans += a[s[i]]
return ans
14. 最长公共前缀
编写一个函数来查找字符串数组中的最长公共前缀。
如果不存在公共前缀,返回空字符串 “”。
示例 1:
输入: ["flower","flow","flight"]
输出: "fl"
示例 2:
输入: ["dog","racecar","car"]
输出: ""
解释: 输入不存在公共前缀。
说明:
所有输入只包含小写字母 a-z 。
解法
- 使用min和max实现
def longestCommonPrefix(strs: List[str]) -> str:
if not strs:
return ""
str_min = min(strs)
str_max = max(strs)
for i, s in enumerate(str_min):
if s != str_max[i]:
return str_min[:i]
return str_min
- 使用zip实现
使用 zip 根据字符串下标合并成数组,
判断合并后数组里元素是否都相同
def longestCommonPrefix(strs: List[str]) -> str:
ans = ''
for i in zip(*strs):
if len(set(i)) == 1:
ans += i[0]
else:
break
return ans
20. 有效的括号
给定一个只包括 ‘(’,’)’,’{’,’}’,’[’,’]’ 的字符串,判断字符串是否有效。
有效字符串需满足:
- 左括号必须用相同类型的右括号闭合。
- 左括号必须以正确的顺序闭合。
- 注意空字符串可被认为是有效字符串。
解法:
- 使用堆栈
def isValid(self, s: str) -> bool:
if not s:
return True
s_dic = {"(": ")", "[": "]", "{": "}"}
stack = []
for c in s:
if c in s_dic.keys():
stack.append(c)
continue
if not stack or c != s_dic[stack.pop()]:
return False
return True if not stack else False # 必须栈为空才是对的
- 巧妙解开
def isValid(s: str) -> bool:
while '{}' in s or '()' in s or '[]' in s:
s = s.replace('{}', '')
s = s.replace('[]', '')
s = s.replace('()', '')
return s == ''
21. 合并两个有序链表
将两个升序链表合并为一个新的 升序 链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。
示例:
输入:1->2->4, 1->3->4
输出:1->1->2->3->4->4
解法:
思路:看到题目的时候第一想法就是创建一个新的链表,然后遍历比较提供的链表将相应的值赋予新的链表。参考了他人的答案后,发现用递归也是可以实现的。
- 遍历实现
# Definition for singly-linked list.
# class ListNode:
# def __init__(self, val=0, next=None):
# self.val = val
# self.next = next
class Solution:
def mergeTwoLists(self, l1: ListNode, l2: ListNode) -> ListNode:
# 创建新的链表且头结点为None
res = ListNode(None)
head = res
# 依次遍历将值赋予新的链表
while l1 and l2:
if l1.val < l2.val:
head.next, l1 = l1, l1.next
else:
head.next, l2 = l2, l2.next
head = head.next
# 将剩余的数值添加到链表之后
if l1:
head.next = l1
else:
head.next = l2
return res.next
- 使用递归来实现
# 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 == None and l2 == None:
return None
if l1 == None:
return l2
if l2 == None:
return l1
if l1.val <= l2.val:
l1.next = self.mergeTwoLists(l1.next,l2)
return l1
else:
l2.next = self.mergeTwoLists(l1,l2.next)
return l2
26. 删除排序数组中的重复项
给定一个排序数组,你需要在 原地 删除重复出现的元素,使得每个元素只出现一次,返回移除后数组的新长度。
不要使用额外的数组空间,你必须在 原地 修改输入数组 并在使用 O(1) 额外空间的条件下完成。
示例 1:
给定数组 nums = [1,1,2],
函数应该返回新的长度 2, 并且原数组 nums 的前两个元素被修改为 1, 2。
你不需要考虑数组中超出新长度后面的元素。
示例 2:
给定 nums = [0,0,1,1,1,2,2,3,3,4],
函数应该返回新的长度 5, 并且原数组 nums 的前五个元素被修改为 0, 1, 2, 3, 4。
你不需要考虑数组中超出新长度后面的元素。
说明:
为什么返回数值是整数,但输出的答案是数组呢?
请注意,输入数组是以「引用」方式传递的,这意味着在函数里修改输入数组对于调用者是可见的。
你可以想象内部操作如下:
// nums 是以“引用”方式传递的。也就是说,不对实参做任何拷贝
int len = removeDuplicates(nums);
// 在函数里修改输入数组对于调用者是可见的。
// 根据你的函数返回的长度, 它会打印出数组中该长度范围内的所有元素。
for (int i = 0; i < len; i++) {
print(nums[i]);
}
解法:
思路:因为题目是要求原地修改数组,所以数组前几位就是需要的。可以尝试使用两个指针来完成,第一个指向当前的数字,另外一个不断往后走读取数据来进行对比。最后需要的长度就是当前指针+1
class Solution:
def removeDuplicates(self, nums: List[int]) -> int:
if not nums:
return 0
now_p = 0
temp_p = 1
while temp_p < len(nums):
if nums[temp_p] == nums[now_p]:
temp_p += 1
continue
now_p += 1
nums[now_p] = nums[temp_p]
return now_p + 1
27. 移除元素
给你一个数组nums
和一个值val
你需要原地
移除所有数值等于val
的元素,并返回移除后数组的新长度。
不要使用额外的数组空间,你必须仅使用 O(1) 额外空间并原地修改输入数组。
元素的顺序可以改变。你不需要考虑数组中超出新长度后面的元素。
示例 1:
给定 nums = [3,2,2,3], val = 3,
函数应该返回新的长度 2, 并且 nums 中的前两个元素均为 2。
你不需要考虑数组中超出新长度后面的元素。
示例 2:
给定 nums = [0,1,2,2,3,0,4,2], val = 2,
函数应该返回新的长度 5, 并且 nums 中的前五个元素为 0, 1, 3, 0, 4。
注意这五个元素可为任意顺序。
你不需要考虑数组中超出新长度后面的元素。
说明:
为什么返回数值是整数,但输出的答案是数组呢?
请注意,输入数组是以「引用」方式传递的,这意味着在函数里修改输入数组对于调用者是可见的。
你可以想象内部操作如下:
// nums 是以“引用”方式传递的。也就是说,不对实参作任何拷贝
int len = removeElement(nums, val);
// 在函数里修改输入数组对于调用者是可见的。
// 根据你的函数返回的长度, 它会打印出数组中 该长度范围内 的所有元素。
for (int i = 0; i < len; i++) {
print(nums[i]);
}
解法:
思路:正着删除比较麻烦,所以可以考虑倒着删除相应元素
class Solution:
def removeElement(self, nums: List[int], val: int) -> int:
# 倒叙遍历,删除即可
for i in range(len(nums)-1, -1, -1):
if(nums[i] == val):
nums.pop(i)
return len(nums)
28. 实现 strStr()
实现 strStr() 函数。
给定一个 haystack 字符串和一个 needle 字符串,在 haystack 字符串中找出 needle 字符串出现的第一个位置 (从0开始)。如果不存在,则返回 -1。
示例 1:
输入: haystack = "hello", needle = "ll"
输出: 2
示例 2:
输入: haystack = "aaaaa", needle = "bba"
输出: -1
说明:
当 needle 是空字符串时,我们应当返回什么值呢?这是一个在面试中很好的问题。
对于本题而言,当 needle 是空字符串时我们应当返回 0 。这与C语言的 strstr() 以及 Java的 indexOf() 定义相符。
解法:
思路:1. 数组切片匹配; 2. 使用python的字符串处理函数
- 切片匹配
class Solution:
def strStr(self, haystack: str, needle: str) -> int:
if not needle:
return 0
l = len(needle)
for i in range(len(haystack)-l+1):
if haystack[i: i+l] == needle:
return i
return -1
- 调用字符串处理函数
return haystack.find(needle)