LeetCode 字符串
基础部分
242. 有效的字母异位词
简单
给定两个字符串 s 和 t ，编写一个函数来判断 t 是否是 s 的字母异位词。
示例 1:
输入: s = "anagram", t = "nagaram"
输出: true
示例 2:
输入: s = "rat", t = "car"
输出: false
说明:
你可以假设字符串只包含小写字母。
进阶:
如果输入字符串包含 unicode 字符怎么办？你能否调整你的解法来应对这种情况？
class Solution {
public boolean isAnagram(String s, String t) {
int[] map = new int[26];
for (char c : s.toCharArray()) map[c-'a']++;
for (char c : t.toCharArray()) map[c-'a']--;
for (int count : map) if (count != 0) return false;
return true;
}
}
409. 最长回文串
简单
给定一个包含大写字母和小写字母的字符串，找到通过这些字母构造成的最长的回文串。
在构造过程中，请注意区分大小写。比如 "Aa" 不能当做一个回文字符串。
注意:
假设字符串的长度不会超过 1010。
示例 1:
输入:
"abccccdd"
输出:
7
解释:
我们可以构造的最长的回文串是"dccaccd", 它的长度是 7。
class Solution {
public int longestPalindrome(String s) {
int[] letters = new int[52];
for (char c : s.toCharArray()){
if (c <= 'Z') letters[c-'A']++;
else letters[c-'a'+26]++;
}
int res = 0, odd = 0;
for (int num : letters){
if (num % 2 == 1) odd = 1;
res += num / 2 * 2;
}
return res + odd;
}
}
205. 同构字符串
简单
给定两个字符串 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 boolean isIsomorphic(String s, String t) {
int len = s.length();
Map<Character,Character> map1 = new HashMap<>();
Map<Character,Character> map2 = new HashMap<>();
for (int i = 0; i < len; i++){
char ch1 = s.charAt(i);
char ch2 = t.charAt(i);
if (map1.containsKey(ch1)){
if (map1.get(ch1) != ch2) return false;
}else if (map2.containsKey(ch2)){
if (map2.get(ch2) != ch1) return false;
}else {
map1.put(ch1, ch2);
map2.put(ch2, ch1);
}
}
return true;
}
}
647. 回文子串
中等
给定一个字符串，你的任务是计算这个字符串中有多少个回文子串。
具有不同开始位置或结束位置的子串，即使是由相同的字符组成，也会被计为是不同的子串。
示例 1:
输入: "abc"
输出: 3
解释: 三个回文子串: "a", "b", "c".
示例 2:
输入: "aaa"
输出: 6
说明: 6个回文子串: "a", "a", "a", "aa", "aa", "aaa".
注意:
- 输入的字符串长度不会超过1000。
class Solution { //O(n^3)
public int countSubstrings(String s) {
int len = s.length();
int res = 0;
for (int i = 0; i < len; i++){
for (int j = i+1; j <= len; j++){
if (is(s.substring(i, j))) res++;
}
}
return res;
}
private boolean is(String s){
int l = s.length();
for (int i = 0; i < l/2; i++){
if (s.charAt(i) != s.charAt(l-i-1))
return false;
}
return true;
}
}
class Solution { //O(n^2)，从里向外的双指针
int res = 0;
public int countSubstrings(String s) {
if (s == null || s.length() == 0) return 0;
int len = s.length();
for (int i = 0; i < len; i++){
helper(s, i, i, len);
helper(s, i, i+1, len);
}
return res;
}
private void helper(String s, int l, int r, int len){
while (l >= 0 && r < len && s.charAt(l) == s.charAt(r)){
res++;
l--;
r++;
}
}
}
9. 回文数
简单
判断一个整数是否是回文数。回文数是指正序（从左向右）和倒序（从右向左）读都是一样的整数。
示例 1:
输入: 121
输出: true
示例 2:
输入: -121
输出: false
解释: 从左向右读, 为 -121 。 从右向左读, 为 121- 。因此它不是一个回文数。
示例 3:
输入: 10
输出: false
解释: 从右向左读, 为 01 。因此它不是一个回文数。
class Solution {
public boolean isPalindrome(int x) {
String s = String.valueOf(x);
for (int i = 0; i < s.length()/2; i++){
if (s.charAt(i) != s.charAt(s.length()-i-1))
return false;
}
return true;
}
}
696. 计数二进制子串
简单
给定一个字符串 s，计算具有相同数量0和1的非空(连续)子字符串的数量，并且这些子字符串中的所有0和所有1都是组合在一起的。
重复出现的子串要计算它们出现的次数。
示例 1 :
输入: "00110011"
输出: 6
解释: 有6个子串具有相同数量的连续1和0：“0011”，“01”，“1100”，“10”，“0011” 和 “01”。
请注意，一些重复出现的子串要计算它们出现的次数。
另外，“00110011”不是有效的子串，因为所有的0（和1）没有组合在一起。
示例 2 :
输入: "10101"
输出: 4
解释: 有4个子串：“10”，“01”，“10”，“01”，它们具有相同数量的连续1和0。
注意：
s.length在1到50,000之间。s只包含“0”或“1”字符。
class Solution {
int res = 0;
public int countBinarySubstrings(String s) {
if (s == null || s.length() == 0) return 0;
char[] chars = s.toCharArray();
int len = chars.length;
for (int i = 0; i < len-1; i++){
if (chars[i] != chars[i+1])
helper(chars, i, i+1, len);
}
return res;
}
private void helper(char[] chars, int l, int r, int len){
char left = chars[l];
char right = chars[r];
do {
res++;
l--;
r++;
}while (l >= 0 && r < len && chars[l] == left && chars[r] == right);
}
}
频率排序
72，5，3，93，468，415，583，556，555，165，214，385，833，536，10，1106，1096，761，564，271，159，722，336，539，97，443，91，758，76，22，227
