本文整理了LeetCode中的一些简单题目，包括两数之和、整数反转、回文数等，提供了Python和Java两种语言的解题代码。这些题目涉及数组、链表、字符串、二叉树等多个数据结构和算法问题。
不得不开始刷LeetCode了，为了使小白的自尊心不受到毁灭性的打击，所以打算从最简单的题开始刷。现把所有题目的Python和Java代码都放在这儿，以便随时回忆。分两种语言的原因在于，Python是我最熟悉也是私心里最喜欢的语言，Java是受众面最广也是我希望学习的语言。以下完全按照LeetCode简单题的顺序出现。预计分5篇博文整理完毕。
题目目录
1. 两数之和
给定一个整数数组
nums和一个目标值target，请你在该数组中找出和为目标值的那 两个 整数，并返回他们的数组下标。你可以假设每种输入只会对应一个答案。但是，你不能重复利用这个数组中同样的元素。示例:给定 nums = [2, 7, 11, 15], target = 9 因为 nums[0] + nums[1] = 2 + 7 = 9 所以返回 [0, 1]
class Solution:
def twoSum(self, nums, target):
"""
:type nums: List[int]
:type target: int
:rtype: List[int]
"""
dict = {}
for i, v in enumerate(nums):
if v in dict:
return [dict[v], i]
else:
dict[target - v] = i class Solution {
public int[] twoSum(int[] nums, int target) {
Map<Integer, Integer> map = new HashMap<>();
for (int i = 0; i < nums.length; i++){
int comp = target - nums[i];
if(map.containsKey(comp)){
return new int[] {map.get(comp), i};
}
map.put(nums[i], i);
}
return new int[] {0,0};
}
}
7. 整数反转
给出一个 32 位的有符号整数，你需要将这个整数中每位上的数字进行反转。
示例 1: 输入: 123 输出: 321
示例 2: 输入: -123 输出: -321
class Solution(object):
def reverse(self, x):
"""
:type x: int
:rtype: int
"""
if -10 < x < 10:
return x
str_x = str(x)
if str_x[0] == "-":
result = -((int)(str_x[1:][::-1]))
else:
result = (int)(str_x[::-1])
if((pow(-2,31) < x < pow(2,31)-1) & (pow(-2,31) < result < pow(2,31)-1)):
return result
else:
return 0
class Solution {
public int reverse(int x) {
int reverse = 0;
while(x != 0){
int ge = x % 10;
x /= 10;
if((reverse > Integer.MAX_VALUE/10) || (reverse == Integer.MAX_VALUE / 10 && ge > 7))
return 0;
if((reverse < Integer.MIN_VALUE/10) || (reverse == Integer.MIN_VALUE / 10 && ge < -8))
return 0;
reverse = reverse * 10 + ge;
}
return reverse;
}
}9. 回文数
判断一个整数是否是回文数。回文数是指正序（从左向右）和倒序（从右向左）读都是一样的整数。
示例 1: 输入: 121 输出: true
示例 2: 输入: -121 输出: false 解释: 从左向右读, 为 -121 。 从右向左读, 为 121- 。因此它不是一个回文数。
class Solution:
def isPalindrome(self, n):
"""
:type x: int
:rtype: bool
"""
p=n
k=0
if n < 0:
return False
while p!=0:
k=k*10+p%10
p=p//10
if k==n:
return True
else:
return Falseclass Solution {
public boolean isPalindrome(int x) {
if(x < 0){
return false;
}
String s = String.valueOf(x);
String ss = new StringBuilder(s).reverse().toString();
if(ss.equals(s)){
return true;
}else{
return false;
}
}
}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 的范围内。
输入: "LVIII" 输出: 58 解释: L = 50, V= 5, III = 3.
class Solution:
def romanToInt(self, s):
"""
:type s: str
:rtype: int
"""
sum=0
convert={'M': 1000,'D': 500 ,'C': 100,'L': 50,'X': 10,'V': 5,'I': 1}
for i in range(len(s)-1):
if convert[s[i]]<convert[s[i+1]]:
sum=sum-convert[s[i]]
else:
sum=sum+convert[s[i]]
return sum+convert[s[-1]]class Solution {
public int romanToInt(String s) {
int sum=0, i;
char ch[] = s.toCharArray();
for(i=0;i<ch.length;i++)
{
switch(ch[i])
{
case 'I':
sum += 1;
break;
case 'V':
if(i!=0 && ch[i-1] == 'I')
sum += 4-1;
else
sum += 5;
break;
case 'X':
if(i!=0 && ch[i-1] == 'I')
sum += 9-1;
else
sum += 10;
break;
case 'L':
if(i!=0 && ch[i-1] == 'X')
sum += 40 -10;
else
sum += 50;
break;
case 'C':
if(i!=0 && ch[i-1] == 'X')
sum += 90-10;
else
sum += 100;
break;
case 'D':
if(i!=0 && ch[i-1] == 'C')
sum += 400-100;
else
sum += 500;
break;
case 'M':
if(i!=0 && ch[i-1] == 'C')
sum += 900-100;
else
sum += 1000;
break;
}
}
return sum;
}
}14. 最长公共前缀
编写一个函数来查找字符串数组中的最长公共前缀。
如果不存在公共前缀，返回空字符串
""。示例 1: 输入: ["flower","flow","flight"] 输出: "fl"
class Solution:
def longestCommonPrefix(self, strs):
"""
:type strs: List[str]
:rtype: str
"""
if not strs:
return ""
if len(strs) == 1:
return strs[0]
minl = min([len(x) for x in strs])
end = 0
while end < minl:
for i in range(1,len(strs)):
if strs[i][end]!= strs[i-1][end]:
return strs[0][:end]
end += 1
return strs[0][:end]
class Solution {
public String longestCommonPrefix3(String[] strs) {
if (strs == null || strs.length == 0)
return "";
if (strs.length == 1)
return strs[0];
int length = strs[0].length();
for (String str : strs) {
length = Math.min(length, str.length());
}
if (length == 0)
return "";
StringBuilder result = new StringBuilder(length);
for (int j = 0; j < length; j++) {
for (int i = 1; i < strs.length; i++) {
if (strs[i].charAt(j) != strs[0].charAt(j))
return result.toString();
}
result.append(strs[0].charAt(j));
}
return result.toString();
}
}
20. 有效的括号
给定一个只包括
'('，')'，'{'，'}'，'['，']'的字符串，判断字符串是否有效。有效字符串需满足：
- 左括号必须用相同类型的右括号闭合。
- 左括号必须以正确的顺序闭合。
注意空字符串可被认为是有效字符串。
class Solution:
def isValid(self, s):
"""
:type s: str
:rtype: bool
"""
stack = []
mapping = {")":"(", "}":"{", "]":"["}
for char in s:
if char in mapping:
top = stack.pop() if stack else '#'
if mapping[char] != top:
return False
else:
stack.append(char)
return not stackclass Solution {
public boolean isValid(String s) {
Stack<Character> stack=new Stack<>();
char[] chs=s.toCharArray();
int len=chs.length;
if((len&1)==1)return false;
for(int i=0;i<len;i++){
if(stack.isEmpty()||!isMatch(stack.peek(),chs[i]))
stack.push(chs[i]);
else
stack.pop();
}
return stack.isEmpty();
}
public boolean isMatch(char a,char b){
switch(a){
case '(': if(b == ')') return true; else return false;
case '{': if(b == '}') return true; else return false;
case '[': if(b == ']') return true; else return false;
default : return false;
}
}
}
21. 合并两个有序链表
将两个有序链表合并为一个新的有序链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。
示例：输入：1->2->4, 1->3->4 输出：1->1->2->3->4->4
# Definition for singly-linked list.
class ListNode:
def __init__(self, x):
self.val = x
self.next = None
class Solution:
def mergeTwoLists(self, l1, l2):
"""
:type l1: ListNode
:type l2: ListNode
:rtype: ListNode
"""
if not l1:
return l2
if not l2:
return l1
if l1.val <= l2.val:
ret = l1
ret.next = self.mergeTwoLists(l1.next, l2)
else:
ret = l2
ret.next = self.mergeTwoLists(l1, l2.next)
return retclass Solution {
class ListNode{
int val;
ListNode next;
ListNode(int x){
val = x;
}
}
public ListNode mergeTwoLists(ListNode l1, ListNode l2) {
if (l1 == null) return l2;
if (l2 == null) return l1;
ListNode head = null;
if (l1.val <= l2.val){
head = l1;
head.next = mergeTwoLists(l1.next, l2);
} else {
head = l2;
head.next = mergeTwoLists(l1, l2.next);
}
return head;
}
}26. 删除排序数组中的重复项
给定一个排序数组，你需要在原地删除重复出现的元素，使得每个元素只出现一次，返回移除后数组的新长度。
不要使用额外的数组空间，你必须在原地修改输入数组并在使用 O(1) 额外空间的条件下完成。
示例 1:给定数组 nums = [1,1,2], 函数应该返回新的长度 2, 并且原数组 nums 的前两个元素被修改为
1,2。 你不需要考虑数组中超出新长度后面的元素。
class Solution:
def removeDuplicates(self, nums):
if len(nums) <= 1:
return len(nums)
s = 0
for f in range(1, len(nums)):
if nums[s] != nums[f]:
s += 1
nums[s] = nums[f]
return s + 1
class Solution {
public int removeDuplicates(int[] nums) {
if(nums.length == 0)
return 0;
int i = 0;
for(int j = 1; j < nums.length; j++){
if(nums[j] != nums[i]){
i++;
nums[i] = nums[j];
}
}
return i+1;
}
}27. 移除元素
给定一个数组 nums 和一个值 val，你需要原地移除所有数值等于 val 的元素，返回移除后数组的新长度。
不要使用额外的数组空间，你必须在原地修改输入数组并在使用 O(1) 额外空间的条件下完成。
元素的顺序可以改变。你不需要考虑数组中超出新长度后面的元素。
示例 1: 给定 nums = [3,2,2,3], val = 3, 函数应该返回新的长度 2, 并且 nums 中的前两个元素均为 2。 你不需要考虑数组中超出新长度后面的元素。
class Solution:
def removeElement(self, nums, val):
"""
:type nums: List[int]
:type val: int
:rtype: int
"""
l = len(nums)
if l == 0:
return 0
i = 0
while i < l:
if nums[i] == val:
nums.pop(i)
l-=1
else:
i+=1
return len(nums)class Solution {
public int removeElement(int[] nums, int val) {
int i = 0;
for(int j = 0; j < nums.length; j++) {
if(nums[j] != val) {
nums[i] = nums[j];
i++;
}
}
return i;
}
}28. 实现strStr()
给定一个 haystack 字符串和一个 needle 字符串，在 haystack 字符串中找出 needle 字符串出现的第一个位置 (从0开始)。如果不存在，则返回 -1。
示例 1: 输入: haystack = "hello", needle = "ll" 输出: 2
class Solution:
def strStr(self, haystack, needle):
"""
:type haystack: str
:type needle: str
:rtype: int
"""
l = len(needle)
for i in range(len(haystack)-l+1):
if haystack[i:i+l] == needle:
return i
return -1class Solution {
public int strStr(String haystack, String needle) {
if(needle.equals("")){
return 0;
}
int len = needle.length();
for(int i = 0; i < haystack.length()-len+1; i++){
if(haystack.substring(i, i+len).equals(needle)){
最低0.47元/天 解锁文章
846
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
