1.两数之和
给定一个整数数组和一个目标值，找出数组中和为目标值的两个数
你可以假设每个输入只对应一种答案，且同样的元素不能被重复利用
示例:
给定 nums = [2, 7, 11, 15], target = 9
因为 nums[0] + nums[1] = 2 + 7 = 9
所以返回 [0, 1]
解决方案
方法一：暴力法
private static int[] twoSum(int[] nums, int target) {
if(nums == null || nums.length == 1) {
return new int[]{0, 0};
}
for (int i = 0; i < nums.length - 1; i++) {
for (int j = i + 1; j < nums.length; j++) {
if (target == nums[i] + nums[j]) {
return new int[] {i, j};
}
}
}
throw new IllegalArgumentException("No two sum solution");
}复杂度分析
时间复杂度：O（n^2）
空间复杂度：O（1）
方法二：哈希表
把数组中的元素作为 key 插入到 hashmap 中，值存元素下标
private static int[] twoSum(int[] nums, int target) {
if (nums == null || nums.length == 1) {
return new int[]{0, 0};
}
Map<Integer, Integer> map = new HashMap<>();
for (int i = 0; i < nums.length; i++) {
int complement = target - nums[i];
if (map.containsKey(complement)) {
return new int[] {map.get(complement), i};
}
map.put(nums[i], i);
}
throw new IllegalArgumentException("No two sum solution");
}复杂度分析：
时间复杂度：O（n）
空间复杂度：O（n）
7.反转整数
给定一个 32 位有符号整数，将整数中的数字进行反转
示例 1:
输入: 123
输出: 321
示例 2:
输入: -123
输出: -321
示例 3:
输入: 120
输出: 21
注意：假设我们的环境只能存储 32 位有符号整数，其数值范围是 [−2^31, 2^31 − 1]。根据这个假设，如果反转后的整数溢出，则返回 0
方法：每次取一个数进行保存，保存之前判断是否有可能会溢出
溢出有四种情况：
a. 上次保存的数 > Integer.MAX_VALUE / 10，则肯定溢出
b. 上次保存的数 == Integer.MAX_VALUE / 10，且当前即将要保存的数大于 7，则会溢出
c. 上次保存的数 < Integer.MIN_VALUE / 10，则肯定溢出
d. 上次保存的数 == Integer.MIN_VALUE / 10，且当前即将要保存的数小于 -8，则会溢出
private static int reverse(int x) {
intrev = 0;
while (x != 0) {
int pop = x % 10;
x /= 10;
if (rev > Integer.MAX_VALUE / 10 || (rev == Integer.MAX_VALUE / 10 && pop > 7)) return 0;
if (rev < Integer.MIN_VALUE / 10 || (rev == Integer.MIN_VALUE / 10 && pop < -8)) return 0;
rev = rev * 10 + pop;
}
return rev;
}复杂度分析
时间复杂度：O（log(n)）
空间复杂度：O（1）
9.回文数
判断一个整数是否是回文数。回文数是指正序（从左向右）和倒序（从右向左）读都是一样的整数
示例 1:
输入: 121
输出: true
示例 2:
输入: -121
输出: false
解释: 从左向右读, 为 -121 。 从右向左读, 为 121- 。因此它不是一个回文数
示例 3:
输入: 10
输出: false
解释: 从右向左读, 为 01 。因此它不是一个回文数
进阶：
你能不将整数转为字符串来解决这个问题吗？
方法：反转后半部分，再和前半部分比较，相等则为回文数
怎么确定一半？
将原始数字除以 10，然后给反转后的数字乘上 10，所以，当原始数字小于反转后的数字时，就意味着我们已经处理了一半位数的数字
private static boolean isPalindrome(int x) {
if (x <0 || (x % 10 == 0 && x != 0)) {
return false;
}
int revertedNumber = 0;
while (x > revertedNumber) {
revertedNumber = revertedNumber * 10 + x % 10;
x /= 10;
}
return x == revertedNumber || x == revertedNumber / 10;
}复杂度分析
时间复杂度：参考给的是 O（log(n)）
空间复杂度：O（1）
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 的范围内
自己写的
private static int romanToInt(String s) {
// 输入的字符串为 null 或长度为 0
if (s == null || s.length() == 0) {
return 0;
}
String roman = "IVXLCDM";
char[] cs = s.toCharArray();
// 遍历输入的字符串
for (int i = 0; i < cs.length; i++) {
// 当前字符不在罗马数字对应的字符范围内
if (!roman.contains(cs[i] + "")) {
return 0;
}
}
// 若连续输入 4 个罗马字符，抛异常，提示罗马数字一般最多为连续三个字符
if (s.contains("IIII") || s.contains("VVVV") || s.contains("XXXX") || s.contains("LLLL") || s.contains("CCCC")
|| s.contains("DDDD") || s.contains("MMMM")) {
throw new IllegalArgumentException("连续字母不能超过三个");
}
Map<Character, Integer> map = new HashMap<>();
map.put('I', 1);
map.put('V', 5);
map.put('X', 10);
map.put('L', 50);
map.put('C', 100);
map.put('D', 500);
map.put('M', 1000);
int len = s.length();
// 初始化 sum 的值，赋值默认取最后一个罗马字符的值
int sum = map.get(s.charAt(len - 1));
for (int i = 0; i < len - 1; i++) {
if (map.get(s.charAt(i)) < map.get(s.charAt(i + 1))) {
sum -= map.get(s.charAt(i));
} else {
sum += map.get(s.charAt(i));
}
}
return sum;
}复杂度分析
时间复杂度：O（n）
空间复杂度：O（n）
14.最长公共前缀
编写一个函数来查找字符串数组中的最长公共前缀
如果不存在公共前缀，返回空字符串 “”
示例 1:
输入: [“flower”,”flow”,”flight”]
输出: “fl”
示例 2:
输入: [“dog”,”racecar”,”car”]
输出: “”
说明:
所有输入只包含小写字母 a-z
自己写的
private static String longestCommonPrefix(String[] strs) {
// 输入的数组为 null，或者数组所含元素个数为 0，即 strs = new String[]{}
if (strs == null) {
// 直接返回空字符串
return "";
} else if (strs.length == 1) {// 输入的数组所含元素个数为 1
// 直接返回该字符串
return strs[0];
}
// 获取输入的数组所含元素个数
int len = strs.length;
// 初始化数组元素最短长度为输入的数组中第一个元素的长度
int lessStrLen = strs[0].length();
// 数组第一个元素长度为 0
if (lessStrLen == 0) {
// 直接返回空字符串
return "";
}
// 从数组下标为 1 处遍历数组
for (int i = 1; i < len; i++) {
// 获取当前位置元素的长度
int currStrLen = strs[i].length();
// 元素长度为 0
if (currStrLen == 0) {
// 返回空字符串
return "";
}
// 如果当前元素长度小于记录的最小元素长度
if (currStrLen < lessStrLen) {
// 更新最小元素长度为当前元素长度
lessStrLen = currStrLen;
}
}
// 创建 map 对象
Map<Character, Integer> map = new HashMap<>(lessStrLen);
// 当前遍历的次数
int index = 0;
// 每轮遍历的个数
int count = 0;
// 当前遍历的字符
char c1 = 0;
// 轮数，即最短元素长度
for (int i = 0; i < lessStrLen; i++) {
// 当前遍历的次数
index = i + 1;
// 开始新的一轮，已遍历的个数清零
count = 0;
// 每一轮的次数，即数组长度
for (int j = 0; j < len; j++) {
// 每次获取数组第 j 个元素的第 i 个字符
c1 = strs[j].charAt(i);
// 从第二个元素开始，map 中若不存在 c1，表示数组下标为 j 的元素，第 i 个字符在 map 中不存在
if (j != 0 && map.get(c1) == null) {
// 返回第 i 个字符之前的字符串
return strs[0].substring(0, i);
}
// 当前第 i 轮遍历的个数加一
count += 1;
// 把 c1 放到数组中，值随意，判断的时候关键是判断 c1 这个 key 对应的 value 是否存在
map.put(c1, j + 1);
}
// 当前第 i 轮遍历结束，把 c1 置空，方便下一轮对字符进行存储、判断
map.put(c1, null);
}
// 最后一轮遍历的个数不等于数组元素的个数，即表示最后一轮没有遍历完就出现了不同的字符
if (count != len) {
// 最后一轮之前的轮数对应的字符串都是相同的，相同的轮数为当前遍历的次数 index - 1
index--;
}
// 返回 index 之前的字符串
return strs[0].substring(0, index);
}复杂度分析
时间复杂度：O（n^2）
空间复杂度：O（n）
20.有效的括号
给定一个只包括 ‘(‘，’)’，’{‘，’}’，’[‘，’]’ 的字符串，判断字符串是否有效。
有效字符串需满足：
左括号必须用相同类型的右括号闭合。
左括号必须以正确的顺序闭合。
注意空字符串可被认为是有效字符串。
示例 1:
输入: “()”
输出: true
示例 2:
输入: “()[]{}”
输出: true
示例 3:
输入: “(]”
输出: false
示例 4:
输入: “([)]”
输出: false
示例 5:
输入: “{[]}”
输出: true
自己写的
private static boolean isValid(String s) {
if (s == null) {
return false;
}
if (s.length() == 0) {
return true;
}
boolean flag = false;
String[] strs = { "()", "{}", "[]" };
while (s.length() != 0) {
flag = false;
for (int i = 0; i < strs.length; i++) {
// 当前字符串包含有效括号
if (s.contains(strs[i])) {
flag = true;
// 剔除当前字符串中的有效括号
s = s.replace(strs[i], "");
// 跳出循环
break;
}
// 此时为遍历有效括号数组 strs 最后一个元素，即有效括号数组在遍历完之前还没有跳出循环
// 则证明当前字符串中含有非有效括号
if (i == strs.length - 1) {
// 返回 falg，此时 flag 为 false
return flag;
}
}
}
// 全部为有效括号，此时 flag 为 true
return flag;
}复杂度分析
时间复杂度：
a. 最好情况，返回 true，即每次都找到有效括号，O（log2(n)）
b. 最差情况，返回 false，数组遍历完也没找到有效括号，O（n）
空间复杂度：O（1）