算法通过村第十二关-字符串|白银笔记|经典面试题
文章目录
- 前言
- 1. 反转问题
-
- 1.1 反转字符串
- 1.2 k个一组反转
- 1.3 仅仅反转字母
-
- 1.3.1 采用栈实现操作
- 1.3.2 采用双指针实现操作
- 1.4 反转字符串里面的单词
-
- 1.4.1 使用语言提供的方法来解决(内置API)
- 1.4.2 如何优雅自己实现上述功能
- 2. 验证回文串
- 3. 字符串中的第一个唯一字符
- 4. 判断是否互为字符重排
-
-
- 4.1 排序重组
- 4.2 采用Hash实现操作
-
- 总结
前言
提示：越是在意的人，越是绝口不提。我选择你，做内心深处的秘密。来日有人剖开这颗心来，里面除了你，什么都没有。 --陶立夏《生活的比喻》
本章挑战的难度不大，是大量字符串题目的基础。务必学扎实。
1. 反转问题
我们知道反转是链表的一个重要考点，反转同样也是字符串的一个重要问题。常见的也就是如下这些：
推荐题目⭐⭐⭐⭐⭐：
344. 反转字符串 - 力扣（LeetCode）
541. 反转字符串 II - 力扣（LeetCode）
917. 仅仅反转字母 - 力扣（LeetCode）
151. 反转字符串中的单词 - 力扣（LeetCode）
557. 反转字符串中的单词 III - 力扣（LeetCode）
这些题目你是否看出一些规律在其中，要么反转字符串，要么反转里面的单词。针对字符的反转可以变换造出很多题目来。这里我们据从基本出发，逐个击破。
1.1 反转字符串
参考题目介绍：344. 反转字符串 - 力扣（LeetCode）
这是最基本的反转题，也是最简单的问题。这里使用双指针最直接。具体的做法是：
对于一个长度为N的待反转的字符串数组，我们观察反转前后的下标的变化，就可以知道结果
s[0] s[N - 1]
s[1] s[N - 2]
s[2] s[N - 3]
s[3] s[N - 4]
s[4] s[N - 5]
... ...
s[n - 1] s[0]
比较完之后我们可以发现规律：即s[i] 与 s[N - 1 -i] 发生了交换。所以双指针我们就可以这样写：
- 将left指向字符串数组的首元素，right指向字符串数组的尾元素
- 当left < right:
- 交换s[left] 和 s[right]
- left 指针右移一位，即left = left + 1
- right指针左移一位，即right = tight -1
- 当left >= right ,反转结束，返回字符数组即可
/**
* 反转字符串（双指针）
* @param s the string
*/
public static void reverseString(char[] s) {
int n = s.length;
for(int left = 0,right = n - 1; left < right; left++,right--){
char c = s[left];
s[left] = s[right];
s[right] = c;
}
}
1.2 k个一组反转
参考题目介绍:541. 反转字符串 II - 力扣（LeetCode）
怎么感觉这题在找事呢？确实是闲了。这里我们根据题意直接模拟结果：
反转每个下标从2k的倍数开始，长度为k的字串。如果字串长度不足k则反转整个字串。
/**
* 反转k个字符串
* @param s
* @param k
* @return
*/
public static String reverseStr(String s, int k) {
if(s == null || s.length=0){
return new String();
}
int n = s.length();
char[] chars = s.toCharArray();
for(int i = 0; i < n; i += 2*k){
reverse(chars,i,Math.min(k + i,n) -1);
}
return new String(chars);
}
public static void reverse(char[] arr, int left, int right) {
while(left < right){
char c = arr[left];
arr[left] = arr[right];
arr[right] = c;
left++;
right--;
}
}
1.3 仅仅反转字母
参考题目介绍：917. 仅仅反转字母 - 力扣（LeetCode）
这里第一眼的感觉是不是很复杂，但同样从两头向中间就可以了，但是问题‘-’不是均匀的有些麻烦，处理起来不容易就增加了难度。其实换一种思路就不同了，栈这个工具，对于反转来说非常好用。
1.3.1 采用栈实现操作
具体方法：
将s中的所有字母单独存放在栈中，所以出栈来说就是反序操作了（当然也可以用数组存并反序的）
然后遍历s的所有字符，如果是字母就输出。
/**
* 仅仅反转字母
* @param s the string to reverse
* @return
*/
public static String reverseOnlyLetters(String s) {
// 校验参数
if (s == null || s.length() == 0) {
return s;
}
// 创建一个栈作存储单词
Stack<Character> letters = new Stack<Character>();
for (Character c : s.toCharArray()){
if (Character.isLetter(c)){
letters.push(c);
}
}
StringBuilder res = new StringBuilder();
for (Character c : s.toCharArray()){
if (Character.isLetter(c)){
res.append(letters.pop());
}else{
res.append(c);
}
}
return res.toString();
}
1.3.2 采用双指针实现操作
一个接一个输出s的所有字符，当遇到一个字母时，我们希望找到逆序遍历字符串的下一个字母。
所以我们这么做：维护一个指针j从后向前遍历字符串，当需要字母的时候就使用它。
/**
* 进反转字母（双指针实现）
* @param s the string to reverse
* @return
*/
public static String reverseOnlyLetters2(String s) {
// 校验参数
if (s == null || s.length() == 0) {
return s;
}
StringBuilder res = new StringBuilder();
int j = s.length() - 1;
for(int i = 0; i < s.length(); i++) {
if (Character.isLetter(s.charAt(i))){
// 可能不止一个
while(!Character.isLetter(s.charAt(j))){
j--;
}
res.append(s.charAt(j--));
}else{
res.append(s.charAt(i));
}
}
return res.toString();
}
1.4 反转字符串里面的单词
参考题目介绍：151. 反转字符串中的单词 - 力扣（LeetCode）
这个题目经常在很多面试题中见到，这样的题目重点在如何处理单词，其实难度并不大，我们重点看下分析：
1.4.1 使用语言提供的方法来解决(内置API)
比如Java，Python，C++等很多语言提供了相关的特性，因此我们可以首先使用语言的特性来解决：
很多语言对字符串都有特殊的处理，提供了split（拆分），reverse(反转) 和 join（连续）等方法。一次采用内置的API是可行的。
- 使用split将字符串按照空格分割成字符串数组；
- 使用reverse将字符串数组进行反转；
- 使用join方法将字符串重新拼接成一个字符串。
如图：
public String reverseWords(String s) {
if(s == null || s.length() == 0){
return s;
}
// 去除开头和结尾的空白字符，这个很重要
s = s.trim();
// 正则匹配连续的字符空白字符作为分隔符
// 正则表达式中\s匹配任何空白字符，包括空格、制表符、换页符等等, 等价于[ \f\n\r\t\v]
List<String> wordList = Arrays.asList(s.split("\\s+"));
Collections.reverse(wordList);
return String.join(" ",wordList);
}
上面的方法，在面试中式禁止使用的，别想了，怎么会这么优雅呢，还是乖乖自己实现吧。
1.4.2 如何优雅自己实现上述功能
对于字符串可变的语言，就不需要在额外开辟空间了，直接在字符串上原地实现，这种情况下，反转字符和去除空格可以一起完成。
/**
* 反转字符串中的单词
* @param s
* @return
*/
public static String reverseWords(String s) {
// 校验参数
if(s == null || s.length() == 0) {
return s;
}
// 出去多余空白字符
StringBuilder sb = trimSpaces(s);
// 反转字符串
reverse(sb,0,sb.length() - 1);
// 反转每个单词
reverseWord(sb);
return sb.toString();
}
private static void reverseWord(StringBuilder sb) {
int n = sb.length();
int start = 0, end = 0;
while(start < n){
// 循环到单词末尾
while(end < n && sb.charAt(end) != ' '){
++end;
}
// 反转单词
reverse(sb,start,end - 1);
// 更新start, 去寻找下一个单词
start = end + 1;
++end;
}
}
/**
* 反转字符出（可变）
* @param sb
* @param left
* @param right
*/
private static void reverse(StringBuilder sb, int left, int right) {
while (left < right){
char temp = sb.charAt(left);
sb.setCharAt(left++,sb.charAt(right));
sb.setCharAt(right--,temp);
}
}
private static StringBuilder trimSpaces(String s) {
int left = 0,right = s.length() - 1;
// 去除掉开头和结尾的空白字符
while (left <= right && s.charAt(left) == ' ') {
left++;
}
while (left <= right && s.charAt(right) == ' ') {
right--;
}
// 将字符串间多余的空白符去掉
StringBuilder sb = new StringBuilder();
while(left <= right){
char c = s.charAt(left);
if (c != ' '){
sb.append(c);
}else if (sb.charAt(sb.length() - 1) != ' '){
sb.append(c);
}
left++;
}
return sb;
}
2. 验证回文串
参考题目地址：125. 验证回文串 - 力扣（LeetCode）
回文问题再链表中也是常见的，再字符串中同样也是重点。（这里记录一下骨头哥☠️的经历技术面式：
第一就式写一个判断字符串回文的问题，题目本身很简单，双指针的典型问题。下面就会被加餐，找最长的回文串（这里就需要动态规划的思想了，这里我们后面再说））
说是话，刷了这么多题目，这个问题真的式手到擒来。有很多思路。最简单的方法就是对字符串进行一次遍历，并保留其中的字母和数字，放入另一个字符串sgood中。这样我们只需要判断sgood是不是一个普通的回文串了。
如果不是用语言的特性，这里我们可以使用双指针的思想来处理。
- 初始，左右指针分别指向sgood的两侧
- 不断向中间移动，判断是否相同，如果相遇就说明是回文串
/**
* 判断是否为回文字符串
* @param s
* @return
*/
public static boolean isPalindrome(String s) {
if (s == null || s.length() == 0) {
return true;
}
StringBuilder sgood = new StringBuilder();
int len = s.length();
for(int i = 0; i < len; i++) {
char c = s.charAt(i);
if (Character.isLetterOrDigit(c)) {
sgood.append(Character.isLowerCase(c));
}
}
int n = sgood.length();
int left = 0,right = n - 1;
while(left < right) {
if (Character.toLowerCase(sgood.charAt(left)) != Character.toLowerCase(sgood.charAt(right))) {
return false;
}
++left;
--right;
}
return true;
}
3. 字符串中的第一个唯一字符
参考题目地址：387. 字符串中的第一个唯一字符 - 力扣（LeetCode）
对于这个问题，最直观的方法就是遍历两次就可以知道结果，采用hash统计字符串中每个字符出现的次数。在第二次遍历时，就可以遍历到只出现1次的字符，直接返回他的索引即可，没有的话返回-1。
/**
* 找只出现一次的字符
* @param s
* @return
*/
public static int firstUniqChar(String s) {
// 参数校验
if(s == null || s.length() == 0){
return 0;
}
Map<Character,Integer> frequency = new HashMap<Character,Integer>();
for(int i = 0; i < s.length(); i++){
char c = s.charAt(i);
frequency.put(c,frequency.getOrDefault(c,0) + 1);
}
for(int i = 0; i < s.length(); i++){
if (frequency.get(s.charAt(i)) == 1){
return i;
}
}
return -1;
}
4. 判断是否互为字符重排
参考题目介绍：242. 有效的字母异位词 - 力扣（LeetCode）
这是一道简单题，就不要想的特别复杂啦。（当然这也是一道非常经典的题目）
这个题目来说，如果你觉得时排列组合的问题，还解决了，说明你排列组合学的很好。但是这里有更好的解法。
4.1 排序重组
将两个字符串全部从小到大或者从大到小排序，然后再逐个比较，不管原始字符串是什么，都可以判断出来，代码也不复杂。
/**
* 判断字符串是否重排
* @param s1
* @param s2
* @return
*/
public static boolean checkPermutation1(String s1, String s2) {
// 将字符串转成数组
char[] chars1 = s1.toCharArray();
char[] chars2 = s2.toCharArray();
// 排序
Arrays.sort(chars1);
Arrays.sort(chars2);
// 比较
return new String(chars1).equals(new String(chars2));
}
这里需要注意我们使用了内置api，面试是不允许的。
4.2 采用Hash实现操作
注意：这里我们不能简单的判断是否已经存在，因为字符串可能在某个串里面重复存在例如“abac”。所以我们可以记录出现的次数，如果一个字符串经过重新排列后，能变成另外一个字符串，那么他们每个不同字符出现的次数是相同的。例如：出现此处不同的，那么便是两个字符串不能够经过重新排列得到。
所以写起来页不复杂，但是长了些。
/**
* 判断字符串是否重排
* @param s1
* @param s2
* @return
*/
public static boolean checkPermutation(String s1, String s2) {
if(s1.length() != s2.length()){
return false;
}
char[] chars = s1.toCharArray();
Map<Character, Integer> s1Map = getMap(s1);
Map<Character, Integer> s2Map = getMap(s2);
for(Character c : chars){
if(!s1Map.containsKey(c) || !s2Map.containsKey(c) || s1Map.get(c).intValue() != s2Map.get(c).intValue() ){
return false;
}
}
return true;
}
/**
* 统计指定字符串str中各字符的出现次数，并以Map的形式返回
* @param str
* @return
*/
public static Map<Character, Integer> getMap(String str) {
Map<Character, Integer> map = new HashMap<>();
char[] chars = str.toCharArray();
for (char aChar : chars) {
map.put(aChar, map.getOrDefault(aChar, 0) + 1);
}
return map;
}
总结
提示：字符串常见问题；双指针问题的回顾；反转问题；回文字符串；重排序问题。
如果有帮助到你，请给题解点个赞和收藏，让更多的人看到 ~ ("▔□▔)/
如有不理解的地方，欢迎你在评论区给我留言，我都会逐一回复 ~
也欢迎你 关注我 ，喜欢交朋友，喜欢一起探讨问题。
