【算法通关村】字符串反转问题解析

反转合集

lc344反转字符串

 public void reverseString(char[] s) {
         if(s==null||s.length()==0){
             return ;
         }
         for(int i=0,j=s.length-1;i<j;i++,j--){
             char c=s[i];
             s[i] = s[j];
             s[j] = c;
         }
     }

lc541K个一组反转

 public String reverseStr(String s, int k) {
         if(s==null||s.length()==0){
             return s;
         }
         int n=s.length();
         char[] arr=s.toCharArray();
         for(int i=0;i<n;i+=2*k){
             reverse(arr,i,Math.min(i+k,n)-1);
         }
         return new String(arr);
     }
     public void reverse(char[] arr,int left,int right){
         while(left<right){
             char temp=arr[left];
             arr[left]=arr[right];
             arr[right]=temp;
             left++;
             right--;
         }
     }

lc917只翻转字母

方式一：双指针。

 //用i和j，对撞型双指针
 public String reverseOnlyLetters(String s) {
         char[] cs=s.toCharArray();
         int i=0,j=s.length()-1;
         while(i<j){
             while(i<j&&!(Character.isLetter(cs[i]))){
                 i++;
             }
             while(i<j&&!(Character.isLetter(cs[j]))){
                 j--;
             }
             if(i<j){
                 char temp=cs[i];
                 cs[i]=cs[j];
                 cs[j]=temp;
                 i++; //不要少
                 j--;
             }
         }
         return new String(cs);
 ​
     }
 //维护一个指针j从后往前遍历字符串，当需要字母时就使用它
 //有一种倒序输出的节奏，前提是满足i是字母
 public String reverseOnlyLetters(String s) {
         if(s==null || s.length()==0){
             return s;
         }
         StringBuilder ans=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--;
                 }
                 ans.append(s.charAt(j--));
             } else {
                 ans.append(s.charAt(i));
             }
         }
         return ans.toString();
     }

方法二：栈，反序输出字符串

 public String reverseOnlyLetters(String s) {
         Stack<Character> letters = new Stack();
         for(char c:s.toCharArray()){
             if(Character.isLetter(c)){
                 letters.push(c);
             }
         }
         StringBuilder ans = new StringBuilder();
         for(char c:s.toCharArray()){
             if(Character.isLetter(c)){
                 ans.append(letters.pop());
             } else {
                 ans.append(c);
             }
         }
         return ans.toString();
     }

lc151反转字符串里的单词

方式一：调api，面试不能用！！！

 public String reverseWords(String s) {
         if(s==null||s.length()==0){
             return s;
         }
         s=s.trim();
         List<String> wordList = Arrays.asList(s.spilt"\\s+"));
         Collections.reverse(wordList);
         return String.join(" ",wordList);
     }

方式二：用双指针找到各个单词，然后存入列表，然后倒序输出

 class Solution {
     public String reverseWords(String s) {
         List<String> words = new ArrayList();
         int n = s.length();
         for (int i = 0, j = 0; i < n; ++i) {
             if (s.charAt(i) != ' ') {
                 j = i;
                 while (i + 1 < n && s.charAt(i + 1) != ' ') ++i;
                 words.add(s.substring(j, i + 1));
             }
         }
         StringBuilder ans = new StringBuilder();
         for (int i = words.size() - 1; i >= 0; --i) {
             ans.append(words.get(i));
             if (i != 0) ans.append(" ");
         }
         return ans.toString();
     }
 }

方式三：官方题解，把每一步都分开写的。去掉开头结尾空格，翻转整个字符串，翻转每个单词，变成正确的次序。

 class Solution {
     public String reverseWords(String s) {
         StringBuilder sb = trimSpaces(s);
         reverse(sb,0,sb.length()-1);
         reverseEachWord(sb);
         return sb.toString();
     }
     public 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;
     }
     public 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);
         }
     }
     public void reverseEachWord(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=end+1;
             end++;
         }
     }
 }

方式四：倒序遍历，倒序添加，双指针思想。

     public String reverseWords(String s) {
         int n = s.length();
         StringBuilder ans = new StringBuilder();
         for (int i = n - 1; i > -1; --i) {
             if (s.charAt(i) == ' ') continue;
             int j = i;
             while (j > 0 && s.charAt(j - 1) != ' ') {
                 --j;
             }
             ans.append(s.substring(j, i + 1)).append(" ");
             i = j;
         }
         return ans.deleteCharAt(ans.length() - 1).toString();
     }