Leetcode字符串刷题顺序
5. 最长回文子串
知识准备：
8. 字符串转换整数 (atoi)
13. 罗马数字转整数
14. 最长公共前缀
28. 实现 strStr()
36. 有效的数独
58. 最后一个单词的长度
125. 验证回文串
文章目录
-
-
-
- [5. 最长回文子串](https://leetcode-cn.com/problems/longest-palindromic-substring/)
-
- 知识准备：
- [8. 字符串转换整数 (atoi)](https://leetcode-cn.com/problems/string-to-integer-atoi/)
- [13. 罗马数字转整数](https://leetcode-cn.com/problems/roman-to-integer/)
- [14. 最长公共前缀](https://leetcode-cn.com/problems/longest-common-prefix/)
- [28. 实现 strStr()](https://leetcode-cn.com/problems/implement-strstr/)
- [36. 有效的数独](https://leetcode-cn.com/problems/valid-sudoku/)
- [58. 最后一个单词的长度](https://leetcode-cn.com/problems/length-of-last-word/)
- [125. 验证回文串](https://leetcode-cn.com/problems/valid-palindrome/)
- [165. 比较版本号](https://leetcode-cn.com/problems/compare-version-numbers/)
- [205. 同构字符串](https://leetcode-cn.com/problems/isomorphic-strings/)
- [242. 有效的字母异位词](https://leetcode-cn.com/problems/valid-anagram/)
- [290. 单词规律](https://leetcode-cn.com/problems/word-pattern/)
- [344. 反转字符串](https://leetcode-cn.com/problems/reverse-string/)
- [345. 反转字符串中的元音字母](https://leetcode-cn.com/problems/reverse-vowels-of-a-string/)
- [383. 赎金信](https://leetcode-cn.com/problems/ransom-note/)
- [387. 字符串中的第一个唯一字符](https://leetcode-cn.com/problems/first-unique-character-in-a-string/)
-
-
5. 最长回文子串
难度中等21 36
给定一个字符串 s，找到 s 中最长的回文子串。你可以假设 s 的最大长度为 1000。
示例 1：
输入: "babad"
输出: "bab"
注意: "aba" 也是一个有效答案。
示例 2：
输入: "cbbd"
输出: "bb"
知识准备：
-
马拉车算法：
过程：主要存储相关点的相关半径，回文中心记录一个值，最大的回文半径，从ｊ点向两边拉伸，回文半径长度
ｊ:回文中心，到右边最远，最远为ｐ主要是求c[i]，c[i]有对称的位置，一种包括ｉ一种不包括，可以找到i’点，
时间复杂度是O(1)的，总的时间复杂度是O(n)的
class Solution {
public:
string get_new_str(string &s) {
//将其字符间加入#解决偶个数字符
string new_s = "#";
for(int i = 0;i < s.size(); i++) {
new_s += s[i];
new_s += "#";
}
return new_s;
}
int r[1005];
string longestPalindrome(string s) {
int r[2010] = {
0};
string new_s = get_new_str(s);//获取处理后的字符串
int ans = 0, ind = 0;
for(int i = 0, j = 0, p = 0; new_s[i];i++ ) {
r[i] = 1;
if(i <= p&&r[2 * j - i] + i - 1 < p) {
//第一种情况,
r[i] = r[2 * j - i];//对称
} else {
//第二种情况
r[i] = max(1, p - i + 1);//找到最大的
while(i >= r[i] && new_s[i + r[i]] == new_s[i - r[i]]) r[i] ++;//一点一点往后试探
}
if(i + r[i] - 1 > p) {
//更新p
j = i, p = i + r[i] - 1;
}
if(r[i] > ans) {
//最大的半径
ans = r[i], ind = i;
}
}
string sub_str = new_s.substr(ind - ans + 1, 2 * ans - 1);
string ret = "";
for(int i = 1;sub_str[i]; i+=2) ret += sub_str[i];
return ret;
}
};
8. 字符串转换整数 (atoi)
难度中等696
请你来实现一个 atoi 函数，使其能将字符串转换成整数。
首先，该函数会根据需要丢弃无用的开头空格字符，直到寻找到第一个非空格的字符为止。接下来的转化规则如下：
- 如果第一个非空字符为正或者负号时，则将该符号与之后面尽可能多的连续数字字符组合起来，形成一个有符号整数。
- 假如第一个非空字符是数字，则直接将其与之后连续的数字字符组合起来，形成一个整数。
- 该字符串在有效的整数部分之后也可能会存在多余的字符，那么这些字符可以被忽略，它们对函数不应该造成影响。
注意：假如该字符串中的第一个非空格字符不是一个有效整数字符、字符串为空或字符串仅包含空白字符时，则你的函数不需要进行转换，即无法进行有效转换。
在任何情况下，若函数不能进行有效的转换时，请返回 0 。
提示：
- 本题中的空白字符只包括空格字符
' '。 - 假设我们的环境只能存储 32 位大小的有符号整数，那么其数值范围为 [−231, 231 − 1]。如果数值超过这个范围，请返回 INT_MAX (231 − 1) 或 INT_MIN (−231) 。
示例 1:
输入: "42"
输出: 42
示例 2:
输入: " -42"
输出: -42
解释: 第一个非空白字符为 '-', 它是一个负号。
我们尽可能将负号与后面所有连续出现的数字组合起来，最后得到 -42 。
示例 3:
输入: "4193 with words"
输出: 4193
解释: 转换截止于数字 '3' ，因为它的下一个字符不为数字。
示例 4:
输入: "words and 987"
输出: 0
解释: 第一个非空字符是 'w', 但它不是数字或正、负号。
因此无法执行有效的转换。
示例 5:
输入: "-91283472332"
输出: -2147483648
解释: 数字 "-91283472332" 超过 32 位有符号整数范围。
因此返回 INT_MIN (−231) 。
- 方法一
class Solution {
public:
int myAtoi(string str) {
int d = 0;
istringstream is(str);//转化为流 is,
is>>d;//然后is 流向整形d中即可转化, 只有d同类型的值往里面流
return d;
}
};
- 方法二
class Solution {
public:
int myAtoi(string str) {
int flag = 1, num = 0, i = 0, pre_max = INT_MAX / 10, d = INT_MAX % 10;
while(str[i] == ' ') i++;
if(str[i] == '-')flag = -1, ++i;
else if(str[i] == '+');
num = num * 10 + (str[i] - '0');
return flag == 1? INT_MAX : INT_MIN;
i++;
}
return num * flag;
}
};
13. 罗马数字转整数
难度简单890
罗马数字包含以下七种字符: 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.
class Solution {
public:
int getVal(char c) {
switch (c) {
case 'I' : return 1;
case 'V' : return 5;
case 'X' : return 10;
case 'L' : return 50;
case 'C' : return 100;
case 'D' : return 500;
case 'M' : return 1000;
}
return 0;
}
int romanToInt(string s) {
int num = 0;
for (int i = 0; s[i]; i++) {
if (s[i + 1] == 0 || getVal(s[i]) >= getVal(s[i + 1])) {
num += getVal(s[i]);
} else {
num -= getVal(s[i]);
}
}
return num;
}
};
14. 最长公共前缀
难度简单1002
编写一个函数来查找字符串数组中的最长公共前缀。
如果不存在公共前缀，返回空字符串 ""。
示例 1:
输入: ["flower","flow","flight"]
输出: "fl"
示例 2:
输入: ["dog","racecar","car"]
输出: ""
解释: 输入不存在公共前缀。
说明:
所有输入只包含小写字母 a-z 。
28. 实现 strStr()
难度简单441
实现 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() 定义相符。
class Solution {
public:
int strStr(string haystack, string needle) {
int ind[256];
for(int i = 0; i < 265; i++) ind[i] = needle.size() + 1;
for(int i = 0; needle[i]; i++) {
ind[needle[i]] = needle.size() - i;
}
for(int i = 0, I = haystack.size() - needle.size(); i <= I;) {
int j = 0;
for(; needle[j]; j++) {
if(haystack[i + j] == needle[j])continue;
i += ind[haystack[i + needle.size()]];
break;
}
if(needle[j] == 0)return i;
}
return -1;
}
};
36. 有效的数独
难度中等330
判断一个 9x9 的数独是否有效。只需要根据以下规则，验证已经填入的数字是否有效即可。
- 数字
1-9在每一行只能出现一次。 - 数字
1-9在每一列只能出现一次。 - 数字
1-9在每一个以粗实线分隔的3x3宫内只能出现一次。
上图是一个部分填充的有效的数独。
数独部分空格内已填入了数字，空白格用 '.' 表示。
示例 1:
输入:
[
["5","3",".",".","7",".",".",".","."],
["6",".",".","1","9","5",".",".","."],
[".","9","8",".",".",".",".","6","."],
["8",".",".",".","6",".",".",".","3"],
["4",".",".","8",".","3",".",".","1"],
["7",".",".",".","2",".",".",".","6"],
[".","6",".",".",".",".","2","8","."],
[".",".",".","4","1","9",".",".","5"],
[".",".",".",".","8",".",".","7","9"]
]
输出: true
示例 2:
输入:
[
["8","3",".",".","7",".",".",".","."],
["6",".",".","1","9","5",".",".","."],
[".","9","8",".",".",".",".","6","."],
["8",".",".",".","6",".",".",".","3"],
["4",".",".","8",".","3",".",".","1"],
["7",".",".",".","2",".",".",".","6"],
[".","6",".",".",".",".","2","8","."],
[".",".",".","4","1","9",".",".","5"],
[".",".",".",".","8",".",".","7","9"]
]
输出: false
解释: 除了第一行的第一个数字从 5 改为 8 以外，空格内其他数字均与 示例1 相同。
但由于位于左上角的 3x3 宫内有两个 8 存在, 因此这个数独是无效的。
说明:
- 一个有效的数独（部分已被填充）不一定是可解的。
- 只需要根据以上规则，验证已经填入的数字是否有效即可。
- 给定数独序列只包含数字
1-9和字符'.'。 - 给定数独永远是
9x9形式的。
class Solution {
public:
int x[9], y[9], z[9];
bool isValidSudoku(vector<vector<char>>& board) {
for (int i = 0; i < 9; i++) x[i] = y[i] = z[i] = 0;//初始化为0
for (int i = 0; i < 9; i++) {
for (int j = 0; j < 9; j++) {
if (board[i][j] == '.') continue;
int num = board[i][j] - '0';
if (x[i] & (1 << num)) return false;
if (y[j] & (1 << num)) return false;
if (z[i / 3 * 3 + j / 3] & (1 << num)) return false;
x[i] |= (1 << num);
y[j] |= (1 << num);
z[i / 3 * 3 + j / 3] |= (1 << num);
}
}
return true;
}
};
58. 最后一个单词的长度
难度简单196
给定一个仅包含大小写字母和空格 ' ' 的字符串 s，返回其最后一个单词的长度。如果字符串从左向右滚动显示，那么最后一个单词就是最后出现的单词。
如果不存在最后一个单词，请返回 0 。
**说明：**一个单词是指仅由字母组成、不包含任何空格字符的 最大子字符串。
示例:
输入: "Hello World"
输出: 5
-
方法一
class Solution { public: int lengthOfLastWord(string s) { reverse(s.begin(),s.end());//翻转一下，让最后一个单词在前面 string w; istringstream is(s); is>>w;//使用流流入w中 return w.size(); } }; -
方法二
class Solution { public: int lengthOfLastWord(string s) { //找到两个空格位置 if (s == "") return 0; int p1 = s.size() - 1, p2; while (p1 >= 0 && s[p1] == ' ') --p1; p2 = p1; while (p2 >= 0 && s[p2] != ' ') --p2; return p1 - p2; } };
125. 验证回文串
难度简单191
给定一个字符串，验证它是否是回文串，只考虑字母和数字字符，可以忽略字母的大小写。
**说明：**本题中，我们将空字符串定义为有效的回文串。
示例 1:
输入: "A man, a plan, a canal: Panama"
输出: true
示例 2:
输入: "race a car"
输出: false
class Solution {
public:
bool isAlpha(char ch) {
return ch <= 'z' && ch >= 'a';
}
bool isDigit(char ch) {
return ch <= '9' && ch >= '0';
}
bool isPalindrome(string s) {
int p1 = 0, p2 = s.size() - 1;
for (int i = 0; s[i]; i++) {
if (s[i] <= 'Z' && s[i] >= 'A') s[i] += 32;
}
while (p1 < p2) {
//两个指针一个往左走，一个往右走
while (p1 < s.size() && !isAlpha(s[p1]) && !isDigit(s[p1])) ++p1;
while (p2 >= 0 && !isAlpha(s[p2]) && !isDigit(s[p2])) --p2;
if (p1 >= p2) break;
if (s[p1] != s[p2]) return false;
p1++, p2--;
}
return true;
}
};
165. 比较版本号
难度中等79
比较两个版本号 version1 和 version2。
如果 *version1* > *version2* 返回 1，如果 *version1* < *version2* 返回 -1， 除此之外返回 0。
你可以假设版本字符串非空，并且只包含数字和 . 字符。
. 字符不代表小数点，而是用于分隔数字序列。
例如，2.5 不是“两个半”，也不是“差一半到三”，而是第二版中的第五个小版本。
你可以假设版本号的每一级的默认修订版号为 0。例如，版本号 3.4 的第一级（大版本）和第二级（小版本）修订号分别为 3 和 4。其第三级和第四级修订号均为 0。
示例 1:
输入: version1 = "0.1", version2 = "1.1"
输出: -1
示例 2:
输入: version1 = "1.0.1", version2 = "1"
输出: 1
示例 3:
输入: version1 = "7.5.2.4", version2 = "7.5.3"
输出: -1
示例 4：
输入：version1 = "1.01", version2 = "1.001"
输出：0
解释：忽略前导零，“01” 和 “001” 表示相同的数字 “1”。
示例 5：
输入：version1 = "1.0", version2 = "1.0.0"
输出：0
解释：version1 没有第三级修订号，这意味着它的第三级修订号默认为 “0”。
提示：
- 版本字符串由以点 （
.） 分隔的数字字符串组成。这个数字字符串可能有前导零。 - 版本字符串不以点开始或结束，并且其中不会有两个连续的点。
代码一、
class Solution {
public:
int compareVersion(string version1, string version2) {
int i = 0, j = 0;
while (version1[i] || version2[j]) {
int val1 = 0;
int val2 = 0;
while (version1[i] && version1[i] <= '9' && version1[i] >= '0') {
val1 = val1 * 10 + version1[i] - '0';
i++;
}
while (version2[j] && version2[j] <= '9' && version2[j] >= '0') {
val2 = val2 * 10 + version2[j] - '0';
j++;
}
if (val1 - val2) return val1 > val2 ? 1 : -1;
if (version1[i]) ++i;
if (version2[j]) ++j;
}
return 0;
}
};
代码二、
class Solution {
public:
int getNext(string &str, int i, int &val) {
val = 0;
while (str[i] && str[i] <= '9' && str[i] >= '0') {
val = val * 10 + str[i] - '0';
i++;
}
if (str[i]) ++i;
return i;
}
int compareVersion(string version1, string version2) {
int i = 0, j = 0, val1, val2;
while (version1[i] || version2[j]) {
i = getNext(version1, i, val1);
j = getNext(version2, j, val2);
if (val1 - val2) return val1 > val2 ? 1 : -1;
}
return 0;
}
};
205. 同构字符串
难度简单193
给定两个字符串 s 和 t，判断它们是否是同构的。
如果 s 中的字符可以被替换得到 t ，那么这两个字符串是同构的。
所有出现的字符都必须用另一个字符替换，同时保留字符的顺序。两个字符不能映射到同一个字符上，但字符可以映射自己本身。
示例 1:
输入: s = "egg", t = "add"
输出: true
示例 2:
输入: s = "foo", t = "bar"
输出: false
示例 3:
输入: s = "paper", t = "title"
输出: true
说明:
你可以假设 s 和 t 具有相同的长度。
class Solution {
public:
bool isIsomorphic(string s, string t) {
if (s.size() - t.size()) return false;
int s_code[256] = {
0}, t_code[256] = {
0};
for (int i = 0; s[i]; i++) {
if (s_code[s[i]] == 0) {
if (t_code[t[i]]) return false;
s_code[s[i]] = t[i];
t_code[t[i]] = s[i];
}
int val = s_code[s[i]];
if (val - t[i]) return false;
}
return true;
}
};
class Solution {
public:
bool isIsomorphic(string s, string t) {
int a[128] = {
0}, b[128] = {
0};
if(s.size()!=t.size())return false;
for(int i = 0; i < s.size(); i++) {
a[s[i]] += i + 1;
b[t[i]] += i + 1;
if(a[s[i]] != b[t[i]]) {
return false;
}
}
return true;
}
};
242. 有效的字母异位词
难度简单192
给定两个字符串 s 和 t ，编写一个函数来判断 t 是否是 s 的字母异位词。
示例 1:
输入: s = "anagram", t = "nagaram"
输出: true
示例 2:
输入: s = "rat", t = "car"
输出: false
说明:
你可以假设字符串只包含小写字母。
进阶:
如果输入字符串包含 unicode 字符怎么办？你能否调整你的解法来应对这种情况？
int cmp(const void *a, const void *b) {
return (*(char *)a - *(char *)b);
}
bool isAnagram(char * s, char * t){
qsort(s, strlen(s), sizeof(char), cmp);
qsort(t, strlen(t), sizeof(char), cmp);
return strcmp(s , t)==0 ? true : false;
}
class Solution {
public:
bool isAnagram(string s, string t) {
if (s.size() - t.size()) return false;
int code[256] = {
0};
for (int i = 0; s[i]; i++) code[s[i]] += 1;
for (int i = 0; t[i]; i++) {
if (code[t[i]] == 0) return false;
code[t[i]] -= 1;
}
return true;
}
};
290. 单词规律
难度简单150
给定一种规律 pattern 和一个字符串 str ，判断 str 是否遵循相同的规律。
这里的 遵循 指完全匹配，例如， pattern 里的每个字母和字符串 str 中的每个非空单词之间存在着双向连接的对应规律。
示例1:
输入: pattern = "abba", str = "dog cat cat dog"
输出: true
示例 2:
输入:pattern = "abba", str = "dog cat cat fish"
输出: false
示例 3:
输入: pattern = "aaaa", str = "dog cat cat dog"
输出: false
示例 4:
输入: pattern = "abba", str = "dog dog dog dog"
输出: false
说明:
你可以假设 pattern 只包含小写字母， str 包含了由单个空格分隔的小写字母。
class Solution {
public:
string getNext(string &s, int &i) {
while (s[i] == ' ') ++i;
string ret = "";
while (s[i] && s[i] != ' ') ret += s[i++];
return ret;
}
bool wordPattern(string p, string s) {
string p_code[256], temp;
unordered_map<string, char> s_code;
int ind = 0;
for (int i = 0; p[i]; i++) {
temp = getNext(s, ind);
if (temp == "") return false;
if (p_code[p[i]] == "") {
if (s_code.find(temp) != s_code.end()) return false;
p_code[p[i]] = temp;
s_code[temp] = p[i];
}
if (p_code[p[i]] != temp) return false;
}
if (s[ind]) return false;
return true;
}
};
344. 反转字符串
难度简单242
编写一个函数，其作用是将输入的字符串反转过来。输入字符串以字符数组 char[] 的形式给出。
不要给另外的数组分配额外的空间，你必须**原地修改输入数组**、使用 O(1) 的额外空间解决这一问题。
你可以假设数组中的所有字符都是 ASCII 码表中的可打印字符。
示例 1：
输入：["h","e","l","l","o"]
输出：["o","l","l","e","h"]
示例 2：
输入：["H","a","n","n","a","h"]
输出：["h","a","n","n","a","H"]
class Solution {
public:
void reverseString(vector<char>& s) {
for (int i = 0, j = s.size() - 1; i < j; i++, j--) {
swap(s[i], s[j]);
}
return ;
}
};
345. 反转字符串中的元音字母
难度简单88
编写一个函数，以字符串作为输入，反转该字符串中的元音字母。
示例 1:
输入: "hello"
输出: "holle"
示例 2:
输入: "leetcode"
输出: "leotcede"
说明:
元音字母不包含字母"y"。
class Solution {
public:
bool is_valid(char ch) {
if (ch < 97) ch += 32;
switch (ch) {
case 'a':
case 'e':
case 'i':
case 'o':
case 'u': return true;
}
return false;
}
string reverseVowels(string s) {
for (int i = 0, j = s.size() - 1; i < j; i++, j--) {
while (i < j && !is_valid(s[i])) ++i;
while (i < j && !is_valid(s[j])) --j;
if (i >= j) break;
swap(s[i], s[j]);
}
return s;
}
};
383. 赎金信
难度简单91
给定一个赎金信 (ransom) 字符串和一个杂志(magazine)字符串，判断第一个字符串 ransom 能不能由第二个字符串 magazines 里面的字符构成。如果可以构成，返回 true ；否则返回 false。
(题目说明：为了不暴露赎金信字迹，要从杂志上搜索各个需要的字母，组成单词来表达意思。杂志字符串中的每个字符只能在赎金信字符串中使用一次。)
注意：
你可以假设两个字符串均只含有小写字母。
canConstruct("a", "b") -> false
canConstruct("aa", "ab") -> false
canConstruct("aa", "aab") -> true
class Solution {
public:
bool canConstruct(string r, string m) {
int code[256] = {
0};
for (int i = 0; m[i]; i++) code[m[i]] += 1;
for (int i = 0; r[i]; i++) {
if (code[r[i]] == 0) return false;
code[r[i]]--;
}
return true;
}
};
387. 字符串中的第一个唯一字符
难度简单211
给定一个字符串，找到它的第一个不重复的字符，并返回它的索引。如果不存在，则返回 -1。
案例:
s = "leetcode"
返回 0.
s = "loveleetcode",
返回 2.
**注意事项：**您可以假定该字符串只包含小写字母。
class Solution {
public:
int firstUniqChar(string s) {
int code[256] = {
0};
for (int i = 0; s[i]; i++) code[s[i]] += 1;
for (int i = 0; s[i]; i++) if (code[s[i]] == 1) return i;
return -1;
}
};