LeetCode基础算法-字符串
LeetCode 算法 字符串
1. 翻转字符串
编写一个函数，其作用是将输入的字符串反转过来。
解题思路：
- 双指针法。
- low = 0 ,high = 字符串长度-1，low与high逐步逼近。
public String reverseString(String s) {
if (s == null) {
return null;
}
int low = 0;
int high = s.length() - 1;
char temp;
char[] chars = s.toCharArray();
while (low < high) {
temp = chars[low];
chars[low] = chars[high];
chars[high] = temp;
low++;
high--;
}
return new String(chars);
}
2. 颠倒整数
给定一个 32 位有符号整数，将整数中的数字进行反转。
假设我们的环境只能存储 32 位有符号整数，其数值范围是 [−231, 231 − 1]。根据这个假设，如果反转后的整数溢出，则返回 0。
解题思路：
- 不断求余+不断求商。
public int reverse(int x) {
long result = 0;
while (x != 0) {
result = result * 10 + x % 10;
x /= 10;
}
if (result > Integer.MAX_VALUE || result < Integer.MIN_VALUE) {
return 0;
}
return (int) result;
}
3. 字符串中的第一个唯一字符
给定一个字符串，找到它的第一个不重复的字符，并返回它的索引。如果不存在，则返回 -1。
注意事项：您可以假定该字符串只包含小写字母。
解题思路：
- 从a-z逐个遍历，查看在S中的indexOf与lastIndexOf的值是否相同。
- 最多遍历26次，如果对S的字符逐个遍历，则效率较低，因为至少需要遍历S长度遍。
public int firstUniqChar(String s) {
int result = -1;
int index;
for (char ch = 'a'; ch <= 'z'; ch++) {
index = s.indexOf(ch);
if (index != -1 && index == s.lastIndexOf(ch)) {
result = result != -1 ? Math.min(index, result) : index;
}
}
return result;
}
4. 异位词
给定两个字符串 s 和 t ，编写一个函数来判断 t 是否是 s 的一个字母异位词。
你可以假设字符串只包含小写字母。
解题思路：
- 若两个词为异位词，那么每个zi字符串中每个字符出现的次数必定相同。
- 两个数组，分别收集两个字符串中字符出现的次数，并比较同一个字符出现的次数是否相同。
public boolean isAnagram(String s, String t) {
if(s.length()!=t.length()){
return false;
}
int[] sCounter = new int[26];
int[] tCounter = new int[26];
for (int i = 0; i < s.length(); i++) {
sCounter[s.charAt(i) - 'a']++;
tCounter[t.charAt(i) - 'a']++;
}
for (int i = 0; i < 26; i++) {
if (sCounter[i] != tCounter[i]) {
return false;
}
}
return true;
}
5. 字符串转整数
实现 atoi，将字符串转为整数。
在找到第一个非空字符之前，需要移除掉字符串中的空格字符。如果第一个非空字符是正号或负号，选取该符号，并将其与后面尽可能多的连续的数字组合起来，这部分字符即为整数的值。如果第一个非空字符是数字，则直接将其与之后连续的数字字符组合起来，形成整数。
字符串可以在形成整数的字符后面包括多余的字符，这些字符可以被忽略，它们对于函数没有影响。
当字符串中的第一个非空字符序列不是个有效的整数；或字符串为空；或字符串仅包含空白字符时，则不进行转换。
若函数不能执行有效的转换，返回 0。
说明：
假设我们的环境只能存储 32 位有符号整数，其数值范围是 [−231, 231 − 1]。如果数值超过可表示的范围，则返回 INT_MAX (231 − 1) 或 INT_MIN (−231) 。
public int myAtoi(String str) {
if (str == null) {
return 0;
}
str = str.trim();
char[] ch = str.toCharArray();
int positive = 1;
double result = 0;
char num;
for (int i = 0; i < ch.length; i++) {
num = ch[i];
if (i == 0) {
if (num != '+' && num != '-' && Character.isDigit(num) == false) {
return 0;
}
if (num == '+') {
positive = 1;
continue;
}
if (num == '-') {
positive = -1;
continue;
}
if (Character.isDigit(num)) {
result = result * 10 + Integer.parseInt(num + "");
}
} else {
if (Character.isDigit(num)) {
result = result * 10 + Integer.parseInt(num + "");
} else {
break;
}
}
}
result *= positive;
if (result > Integer.MAX_VALUE) {
return Integer.MAX_VALUE;
}
if (result < Integer.MIN_VALUE) {
return Integer.MIN_VALUE;
}
return (int) result;
}
6. 实现strStr
实现 strStr() 函数。
给定一个 haystack 字符串和一个 needle 字符串，在 haystack 字符串中找出 needle 字符串出现的第一个位置 (从0开始)。如果不存在，则返回 -1。
public int strStr(String haystack, String needle) {
if (needle == null || needle.isEmpty()) {
return 0;
}
if (haystack.length() < needle.length()) {
return -1;
}
int i, j;
int[] next = getNext(needle);
for (i = 0, j = 0; i < haystack.length(); i++) {
while (j > 0 && haystack.charAt(i) != needle.charAt(j)) {
j = next[j - 1];
}
if (haystack.charAt(i) == needle.charAt(j)) {
j++;
}
if (j == needle.length()) {
return i - j + 1;
}
}
return -1;
}
private int[] getNext(String str) {
char[] strKey = str.toCharArray();
int[] next = new int[str.length()];
next[0] = 0;
int index = 1;
for (index = 1; index < str.length(); index++) {
int k = next[index - 1];
while (strKey[index] != strKey[k] && k != 0) {
k = next[k - 1];
}
if (strKey[index] == strKey[k]) {
next[index] = k + 1;
} else {
next[index] = 0;
}
}
return next;
}
7. 最长回文子串
给定一个字符串 s，找到 s 中最长的回文子串。你可以假设 s 的最大长度为1000。
示例 1：
输入: "babad"
输出: "bab"
注意: "aba"也是一个有效答案。
示例 2：
输入: "cbbd"
输出: "bb"
public String longestPalindrome(String s) {
// 1. 使用动态规划
// dp[i][j]代表索引i到索引j是否为回文串
// dp[i][]:1.i==j,true;2.s[i]=[j]&&dp[i+1][j-1]
boolean[][] dp = new boolean[s.length()][s.length()];
int start = 0;
int maxLength = 1;
for (int i = 0; i < s.length(); i++) {
for (int j = 0; j <= i; j++) {
if (i - j < 2) {
dp[j][i] = s.charAt(i) == s.charAt(j);
} else {
dp[j][i] = (s.charAt(i) == s.charAt(j)) && dp[j + 1][i - 1];
}
if (dp[j][i] && maxLength < (i - j + 1)) {
maxLength = i - j + 1;
start = j;
}
}
}
return s.substring(start, maxLength + start);
// 2.使用Manacher算法
// 在每个字符的前后插入#，分别计算每个字符的最大回文字符串长度。
// 找出最大长度，然后截取字符串
int sLength = s.length();
int helperLength = 2 * sLength + 1;
char[] helpers = new char[helperLength];
Arrays.fill(helpers, '#');
for (int i = 0, j = 1; i < s.length(); i++, j += 2) {
helpers[j] = s.charAt(i);
}
int[] palindromeNums = new int[helperLength];
palindromeNums[0] = 0;
palindromeNums[helperLength - 1] = 0;
for (int i = 1; i < helperLength - 1; i++) {
int length = 0;
int left = i - 1;
int right = i + 1;
while (left >= 0 && right < helperLength) {
if (helpers[left] == helpers[right]) {
left--;
right++;
length++;
} else {
break;
}
}
if (length != 0) {
length = length + 1;
}
palindromeNums[i] = length;
}
int maxLength = 0;
int index = 0;
for (int i = 1; i < helperLength - 1; i++) {
if (palindromeNums[i] > maxLength) {
maxLength = palindromeNums[i];
index = i;
}
}
if (maxLength == 0) {
return "";
} else {
int left = index - maxLength + 1;
int right = index + maxLength - 1;
StringBuilder sBuilder = new StringBuilder();
for (int i = left; i <= right; i++) {
if (helpers[i] != '#') {
sBuilder.append(helpers[i]);
}
}
return sBuilder.toString();
}
}