在LeetCode初级算法的字符串专题中，共给出了九道题目，分别为：反转字符串，整数反转，字符串中的第一个唯一字符，有效的字母异位词，验证回文字符串，字符串转换整数，实现strStr(),报数，最长公共前缀。涉及到字符串的常规应用和一些算法技巧，依次记录如下。
反转字符串（344）
题目描述：编写一个函数，其作用是将输入的字符串反转过来。输入字符串以字符数组 char[] 的形式给出。不要给另外的数组分配额外的空间，你必须原地修改输入数组、使用 O(1) 的额外空间解决这一问题。可以假设数组中的所有字符都是 ASCII 码表中的可打印字符。
例如：输入：["h","e","l","l","o"] 输出：["o","l","l","e","h"]
解析：
若给出的是字符数组，则可以直接通过简单的首尾交换完成反转；若给出的是一个字符串，有三种方法：（1）将String变为StringBuffer，借助StringBuffer类的reverse()方法直接完成反转；（2）通过String的toCharArray()方法变为字符数组，首尾交换；（3）借助栈的先进后出实现。
//方法一：首尾交换，输入为字符数组
public void reverseString(char[] s) {
int len = s.length; //数组长度
for(int i=0;i<len/2;i++){ //遍历一半长度，首尾交换
char temp=s[i];
s[i]=s[len-i-1];
s[len-i-1]=temp;
}
}
//方法二：StringBuffer的reverse方法，输入为String
public String reverseString(String s) {
StringBuffer result = new StringBuffer(s);
result = result.reverse(); //调用reverse方法
return result.toString();
}
整数反转（7）
题目描述：给出一个 32 位的有符号整数，你需要将这个整数中每位上的数字进行反转，反转后如果整数溢出则返回0。
例如： 输入: 123 输出: 321 输入: -123 输出: -321
解析：
类似于反转字符串，整数反转也有两种方法，（1）将整数转为字符串，通过字符串的反转来实现整数的反转，整数转字符串String.valueOf(num),字符串转整数Integer.parseInt(str);(2)弹出和压入数字，通过pop = x % 10;取出末尾数字，压入到结果的前面。显然，方法二较好。
这里需要注意的还有整数溢出的处理，同样有两种方法，一种可以通过java的异常机制，捕获对应的整数溢出异常，进行处理（NumberFormatException），还有一种是进行提前进行数字是否溢出的检查。
//方法一，转为字符串实现
public int reverse(int x) {
String s=String.valueOf(x);
if(x<0)
s=s.substring(1);
StringBuffer strBuf = new StringBuffer(s);
String str=strBuf.reverse().toString();
try{
return x>0 ? Integer.parseInt(str) : -1*Integer.parseInt(str);
}catch(NumberFormatException e){
return 0;
}
}
//方法二，弹出和推入数字 & 溢出前进行检查
public int reverse(int x) {
int rev = 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;
}
字符串中的第一个唯一字符（387）
题目描述：给定一个字符串，找到它的第一个不重复的字符，并返回它的索引。如果不存在，则返回 -1。
例如：s = "leetcode" 返回 0. s = "loveleetcode",返回 2.
解析：
方法一：用哈希表建立每个字符和其出现次数的映射，然后按顺序遍历字符串，找到第一个出现次数为1的字符，返回其位置即可。方法二：使用模式匹配从前(indexOf)和从后(lastIndexOf)匹配每一个字符，相等即为唯一。
//方法一：哈希表
public int firstUniqChar(String s) {
Map<Character,Integer> map = new HashMap<Character,Integer>();
for(int i=0;i<s.length();i++){
char c=s.charAt(i);
map.put(c,map.getOrDefault(c,0)+1);
}
for(int i=0;i<s.length();i++)
if(map.get(s.charAt(i))==1)
return i;
return -1;
}
//方法二：模式匹配
public int firstUniqChar(String s) {
for(int i=0;i<s.length();i++){
char c=s.charAt(i);
if(s.indexOf(c)==s.lastIndexOf(c))
return i;
}
return -1;
}
有效的字母异位词(242)
题目描述：给定两个字符串 s 和 t ，编写一个函数来判断 t 是否是 s 的一个字母异位词。
例如：输入: s = "anagram", t = "nagaram" 输出: true
解析：
方法一：用哈希表建立每个字符和其出现次数的映射，然后判断两个字符串建立的哈希表是否相同；方法二，将字符串转为字符数组，对字符数组排序，比较排序之后的数组是否相同。方法三：哈希表的变化，如果只有小写字母，可以用数组代替哈希表，一个字符串+，一个字符串-，若是字母异位词，所有值都为0.
//方法一：哈希表
public boolean isAnagram(String s, String t) {
if(s.length()!=t.length())
return false;
Map<Character,Integer> s_map=new HashMap<Character,Integer>();
Map<Character,Integer> t_map=new HashMap<Character,Integer>();
for(int i=0;i<s.length();i++){
char si=s.charAt(i),ti=t.charAt(i);
s_map.put(si,s_map.getOrDefault(si,0)+1);
t_map.put(ti,t_map.getOrDefault(ti,0)+1);
}
if(s_map.entrySet().equals(t_map.entrySet()))
return true;
return false;
}
//方法二：字符数组排序
public boolean isAnagram(String s, String t) {
if (s.length() != t.length()) {
return false;
}
char[] str1 = s.toCharArray();
char[] str2 = t.toCharArray();
Arrays.sort(str1);
Arrays.sort(str2);
return Arrays.equals(str1, str2);
}
//方法三：哈希表的变化，如果只有小写字母，可以用数组代替哈希表
public boolean isAnagram(String s, String t) {
if (s.length() != t.length())
return false;
int[] counter = new int[26];
for (int i = 0; i < s.length(); i++) {
counter[s.charAt(i) - 'a']++;
counter[t.charAt(i) - 'a']--;
}
for (int count : counter) {
if (count != 0)
return false;
}
return true;
}
实现strStr() (28)
题目描述：给定一个 haystack 字符串和一个 needle 字符串，在 haystack 字符串中找出 needle 字符串出现的第一个位置 (从0开始)。如果不存在，则返回-1。
例如：输入: haystack = "hello", needle = "ll" 输出: 2
本题与C语言的 strstr() 以及 Java的 indexOf() 定义相符。具体可以参见另一篇博客"串的模式匹配算法"。
验证回文串 （125）
题目描述：给定一个字符串，验证它是否是回文串，只考虑字母和数字字符，可以忽略字母的大小写。将空字符串定义为有效的回文串。
例如：输入: "A man, a plan, a canal: Panama" 输出: true
解析：
方法一：暴力解决,去掉字符串中的特殊字符，将所有字母变为小写（toLowerCase），然后首尾比较。方法二：对撞指针（类似于快排的思想），两端扫描，特殊字符跳过。
//方法一：暴力解决
public boolean isPalindrome(String s) {
s=s.toLowerCase(); //全部变为小写
char[] strArray = s.toCharArray(); //变为字符数组
String str = "";
for(char c:strArray)
if((c>='a'&&c<='z')||(c>='0'&&c<='9'))
str += c;
int len=str.length();
for(int i=0;i<len/2;i++)
if(str.charAt(i)!=str.charAt(len-1-i))
return false;
return true;
}
//方法二：对撞指针
public boolean isPalindrome(String s) {
s=s.toLowerCase(); //全部变为小写
int len=s.length();
for(int i=0,j=len-1;i<j;){
char si=s.charAt(i),sj=s.charAt(j);
if(!((si>='a'&&si<='z')||(si>='0'&&si<='9')))
i++;
else if(!((sj>='a'&&sj<='z')||(sj>='0'&&sj<='9')))
j--;
else if(si!=sj)
return false;
else{
i++;
j--;
}
}
return true;
}
字符串转换整数atoi（8）
题目描述：请你来实现一个 atoi 函数，使其能将字符串转换成整数。首先，该函数会根据需要丢弃无用的开头空格字符，直到寻找到第一个非空格的字符为止。当我们寻找到的第一个非空字符为正或者负号时，则将该符号与之后面尽可能多的连续数字组合起来，作为该整数的正负号；假如第一个非空字符是数字，则直接将其与之后连续的数字字符组合起来，形成整数。该字符串除了有效的整数部分之后也可能会存在多余的字符，这些字符可以被忽略，它们对于函数不应该造成影响。
例如：输入: "4193 with words" 输出: 4193
解析：题目比较简单，依次处理字符串开头为数字，为"+",为"-",或者为其他字符的情况。
public int myAtoi(String str) {
str = str.trim(); //去掉两边的空格
if(str.length()==0)
return 0;
char first = str.charAt(0);
String res="";
if(first>='0'&&first<='9') //首字母为数字
res += first;
else if(first=='-'||first=='+'){ //首字母为正负号，需要判断后续字符是否为数字
if(str.length()==1)
return 0;
char second = str.charAt(1);
if(second>='0'&&second<='9')
res +=first;
}
if(res!=""){ //存在数字
for(int i=1;i<str.length();i++){
char c=str.charAt(i);
if(c>='0'&&c<='9')
res += c;
else
break;
}
}
else return 0;
try{
return Integer.parseInt(res);
}catch(NumberFormatException e){
if(res.charAt(0)=='-')
return Integer.MIN_VALUE;
else
return Integer.MAX_VALUE;
}
}
报数（38）
报数序列是一个整数序列，按照其中的整数的顺序进行报数，得到下一个数。其前五项如下，给定一个正整数 n（1 ≤ n ≤ 30），输出报数序列的第 n 项。
1. 1
2. 11
3. 21
4. 1211
5. 111221
解析：当前n的报数结果是基于n-1的报数结果，基于n-1的结果对字符串进行分析即可，相当于按序统计n-1结果的字符种类及数目。
public String countAndSay(int n) {
String[] res = new String[n+1];
res[1]="1";
for(int i=2;i<n+1;i++){
int count=1;
res[i]="";
char pre = res[i-1].charAt(0); //前一个字符
for(int j=1;j<res[i-1].length();j++){
char c=res[i-1].charAt(j);
if(c==pre) //相等计数加一
count++;
else{ //不相等写入结果，count重新置为1
res[i] += String.valueOf(count)+pre;
count = 1;
pre = c;
}
}
res[i] += String.valueOf(count)+pre;
}
System.out.println(res[n]);
return res[n];
}
最长公共前缀 （14）
编写一个函数来查找字符串数组中的最长公共前缀。如果不存在公共前缀，返回空字符串 ""。所有输入只包含小写字母 a-z 。
例如：输入: ["flower","flow","flight"] 输出: "fl"
解析：此题有多种方法可解，方法一：水平扫描法，前i个字符串的公共前缀与第i+1个字符串的公共前缀就是前i+1个字符串的公共前缀；方法二：垂直扫描法，将每个字符串的第i个字符（i从0开始）依次比较；方法三：分治法，用分治的思想将原问题分解为两个子问题。
//方法一：水平扫描
public String longestCommonPrefix(String[] strs) {
if(strs.length==0)
return "";
//最长公共前缀长度不会超过其中的任意一个
String prefix = strs[0]; //假设第一个字符串就是最长公共前缀，通过比较逐渐缩短
int j;
for(int i=1;i<strs.length;i++){
int len=strs[i].length()<prefix.length() ? strs[i].length() : prefix.length();
for(j=0;j<len;j++){ //与strs[i]比较，最长可能为len
if(prefix.charAt(j)!=strs[i].charAt(j))
break; //不等，停止，最长为j
}
if(j==0)
return "";
prefix = prefix.substring(0,j);
}
return prefix;
}
//方法三：分治法
public String longestCommonPrefix(String[] strs) {
if (strs == null || strs.length == 0) return "";
return longestCommonPrefix(strs, 0 , strs.length - 1);
}
private String longestCommonPrefix(String[] strs, int l, int r) {
if (l == r)
return strs[l];
else {
int mid = (l + r)/2;
String lcpLeft = longestCommonPrefix(strs, l , mid);
String lcpRight = longestCommonPrefix(strs, mid + 1,r);
return commonPrefix(lcpLeft, lcpRight);
}
}
String commonPrefix(String left,String right) {
int min = Math.min(left.length(), right.length());
for (int i = 0; i < min; i++)
if ( left.charAt(i) != right.charAt(i) )
return left.substring(0, i);
return left.substring(0, min);
}
总结
本博客记录了LeetCode初级算法中的字符串模块给出的9道典型题目，重点是字符串的相关操作以及主要的算法技巧的应用，如对撞指针，哈希表，分治思想等等。