leetcode题解-344. Reverse String && 541. Reverse String II && 345. Reverse Vowels of a String

今天的三道都是字符串反转的题目，也相对比较简单，我们先来看第一道题目：

Write a function that takes a string as input and returns the string reversed.

Example:
Given s = "hello", return "olleh".

本题没什么好说的就是一个最简单的字符串反转问题，可以自己写程序使用两个指针也可以调用内置函数，两种方法代码如下所示：

//内置函数
public String reverseString(String s) {
StringBuilder res = new StringBuilder(s);
return res.reverse().toString();
}

//双指针法
public String reverseString1(String s) {
char[] word = s.toCharArray();
int i = 0;
int j = s.length() - 1;
while (i < j) {
char temp = word[i];
word[i] = word[j];
word[j] = temp;
i++;
j--;
}
return new String(word);
}

541、 Reverse String II题目：

Given a string and an integer k, you need to reverse the first k characters for every 2k characters counting from the start of the string. If there are less than k characters left, reverse all of them. If there are less than 2k but greater than or equal to k characters, then reverse the first k characters and left the other as original.
Example:
Input: s = "abcdefg", k = 2
Output: "bacdfeg"
Restrictions:
The string consists of lower English letters only.
Length of the given string and k will in the range [1, 10000]

本题是将字符串中的每2k个字符的前k个进行反转，后k个保持不变，如果最后剩下的不足k个则全部翻转，大于等于k个则将前k个反转。可以使用上面的双指针法来解决此题，先看我的解法：

//35%
public static String reverseStr(String s, int k) {
char [] res = s.toCharArray();
int n = s.length()/(2*k), i;
//取前面2k*n个进行反转
for(i=0; i<n; i++){
int left=i*2*k, right=left+k-1;
while(left < right){
char tmp = res[left];
res[left] = res[right];
res[right] = tmp;
left ++;
right --;
}
}
//对最后剩余的进行反转，right设置为k和剩余字符串的较小值
int left=i*2*k, right=Math.min(left+k-1, s.length()-1);
while(left < right){
char tmp = res[left];
res[left] = res[right];
res[right] = tmp;
left ++;
right --;
}
return new String(res);
}

其实仔细一想上面的代码是可以进行简化的，可以把后面的判断语句也融合到前面的循环当中，

//44%
public String reverseStr1(String s, int k) {
char[] arr = s.toCharArray();
int n = arr.length;
int i = 0;
while(i < n) {
int j = Math.min(i + k - 1, n - 1);
swap(arr, i, j);
i += 2 * k;
}
return String.valueOf(arr);
}
private void swap(char[] arr, int l, int r) {
while (l < r) {
char temp = arr[l];
arr[l++] = arr[r];
arr[r--] = temp;
}
}

然后在理清反转关系之后我们还可以使用StringBuilder内置的insert函数进行简化反转操作：

//68%
public String reverseStr2(String s, int k) {
StringBuilder res = new StringBuilder();
for (int i = 0; i < s.length(); i++) {
if (i % (2 * k) < k) res.insert(i - i % (2 * k), s.charAt(i));
else res.append(s.charAt(i));
}
return res.toString();
}

接下来看最后一道题目：

Write a function that takes a string as input and reverse only the vowels of a string.

Example 1:
Given s = "hello", return "holle".

Example 2:
Given s = "leetcode", return "leotcede".

Note:
The vowels does not include the letter "y".

只反转字符串中的元音“aeiouAEIOU”，有下面三种方法，思路是一样的，都是双指针法，从两侧找元音然后翻转，只是判断元音的数据结构不同，代码的效率也有很大差异，从中我们可以得到下面的结论：

字符串的contains函数效率没有Set效率高，但是这种数据结构的效率都远低于switch语句来的简单方便

//18%，使用字符串存储元音，然后使用contains函数判断
public String reverseVowels(String s) {
if(s == null || s.length()==0) return s;
String vowels = "aeiouAEIOU";
char[] chars = s.toCharArray();
int start = 0;
int end = s.length()-1;
while(start<end){

while(start<end && !vowels.contains(chars[start]+"")){
start++;
}

while(start<end && !vowels.contains(chars[end]+"")){
end--;
}

char temp = chars[start];
chars[start] = chars[end];
chars[end] = temp;

start++;
end--;
}
return new String(chars);
}

//55%，使用set存储元音，然后使用contains（）函数判断
public String reverseVowels1(String s) {
char[] list=s.toCharArray();
Set<Character> set=new HashSet<>();
set.add('a');
set.add('e');
set.add('i');
set.add('o');
set.add('u');
set.add('A');
set.add('E');
set.add('I');
set.add('O');
set.add('U');
for (int i=0, j=list.length-1; i<j; ) {
if (!set.contains(list[i])) {
i++;
continue;
}
if (!set.contains(list[j])) {
j--;
continue;
}
char temp=list[i];
list[i]=list[j];
list[j]=temp;
i++;
j--;
}
return String.valueOf(list);
}

public static boolean isVowel(char a){
switch(a){
case ('a') : return true;
case ('e') : return true;
case ('i') : return true;
case ('o') : return true;
case ('u') : return true;
case ('A') : return true;
case ('E') : return true;
case ('I') : return true;
case ('O') : return true;
case ('U') : return true;
default : return false;
}
}

//99%，直接使用switch语句判断是否为元音
public static String reverseVowels2(String s) {
if (s.length()<2) return s;

char[] tab = s.toCharArray();
int j = tab.length - 1;
int i = 0;

while( i < j ) {

if (!isVowel(tab[i]))
i++;
else {
while (j!=i && !isVowel(tab[j]))
j--;

char temp = tab[i];
tab[i] = tab[j];
tab[j] = temp;
i++;
j--;
}
}
return new String(tab);
}