字符串刷题篇1

反转字符串

编写一个函数，其作用是将输入的字符串反转过来。输入字符串以字符数组 char[] 的形式给出。

不要给另外的数组分配额外的空间，你必须原地修改输入数组、使用 $O(1)$ 的额外空间解决这一问题。

你可以假设数组中的所有字符都是 ASCII 码表中的可打印字符。

示例 1：
输入：[“h”,“e”,“l”,“l”,“o”]
输出：[“o”,“l”,“l”,“e”,“h”]

示例 2：
输入：[“H”,“a”,“n”,“n”,“a”,“h”]
输出：[“h”,“a”,“n”,“n”,“a”,“H”]

方法:双指针

class Solution {
    public void reverseString(char[] s) {
        //双指针,头尾交换,指针相遇,转化完成
        int left=0;
        int right=s.length-1;
        while(left<right){
            char temp=s[left];
            s[left]=s[right];
            s[right]=temp;
            left++;
            right--;
        }
    }
}

反转字符串(2k一组返回前k)

给定一个字符串 s 和一个整数 k，你需要对从字符串开头算起的每隔 2k 个字符的前 k 个字符进行反转。

如果剩余字符少于 k 个，则将剩余字符全部反转。

如果剩余字符小于 2k 但大于或等于 k 个，则反转前 k 个字符，其余字符保持原样。

示例:

输入: s = “abcdefg”, k = 2
输出: “bacdfeg”

方法:
双指针

class Solution {
    public String reverseStr(String s, int k) {
        //开始反转索引index,反转结束索引end(根据反转情况定,不是k就是,k剩余的)
        char[] ch=s.toCharArray();
        for(int i = 0;i < ch.length;i=i+2*k){
            int start=i;
            //end的确定,只能最多是start+k
            int end=Math.min(start+k-1,ch.length-1);
            //开始反转
            while(start<end){
                ch[start]^=ch[end];
                ch[end]^=ch[start];
                ch[start]^=ch[end];
                start++;
                end--;
            }
        }
        return new String(ch);
    }
}

空格替换

请实现一个函数，把字符串 s 中的每个空格替换成"%20"。

示例 1： 输入：s = “We are happy.”
输出：“We%20are%20happy.”

方法:
暴力,直接复制
双指针:扩容复制

class Solution {
    public String replaceSpace(String s) {
        //申请stringBuilder追加,空就换%20,不是空就直接追加
        StringBuilder str=new StringBuilder();
        for(int i=0;i<s.length();i++){
            if(s.charAt(i)==' '){
                str.append("%20");
            }else{
                str.append(s.charAt(i));
            }
        }
        return str.toString();
    }
}

class Solution {
    public String replaceSpace(String s) {
    //双指针法:left在原始最后,right在扩容的最后位置,替换原则
     StringBuilder str=new StringBuilder();
     for(int i=0;i<s.length();i++){
         if(s.charAt(i)==' '){
             str.append("  ");
         }
     }
    //拼接前后确定指针
    int left=s.length()-1;
    s+=str.toString();
    int right=s.length()-1;
    char[] ch= s.toCharArray();
        while(left<right){//左右指针相遇了,就没有空格了
            if(ch[left]==' '){
                ch[right--]='0';
                ch[right--]='2';
                ch[right]='%';
            }else{
                ch[right]=ch[left];
            }
            left--;
            right--;
        }
        return new String(ch);
    }
}

反转字符串的单词

给定一个字符串，逐个翻转字符串中的每个单词。

示例 1：
输入: “the sky is blue”
输出: “blue is sky the”

示例 2：
输入: " hello world! "
输出: “world! hello”
解释: 输入字符串可以在前面或者后面包含多余的空格，但是反转后的字符不能包括。

示例 3：
输入: “a good example”
输出: “example good a”
解释: 如果两个单词间有多余的空格，将反转后单词间的空格减少到只含一个。

方法:
先让字符串变干净
暴力:申请数组反向追加
双指针:花式反转

class Solution {
    public String reverseWords(String s) {
      //去除多余空格  
      int start=0;
      int end=s.length()-1;
      while(s.charAt(start)==' ') start++;
      while(s.charAt(end)==' ') end--;
      StringBuilder sb=new StringBuilder();
      for(int i=start;i<=end;i++){
          if(s.charAt(i)==' '&&sb.charAt(sb.length()-1)==' ');
          else sb.append(String.valueOf(s.charAt(i)));
      }

      //干净的字符串
      String str=new String(sb);
      //TODO:这里可以优化:不用申请数组,直接在原来的基础上反转字符串,然后依据空格反转回单词
      String[] strArr=str.split(" ");
      s="";
      for(int i=strArr.length-1;i>=0;i--){
          if(i==0) s+=strArr[i];
          else s+=strArr[i]+" ";
      }
      return s; 
    }
}

class Solution {
    public String reverseWords(String s) {
      //干净的字符串
      s=removeSpace(s);
      //TODO:这里可以优化:不用申请数组,直接在原来的基础上反转字符串,然后依据空格反转回单词
      StringBuilder sb=new StringBuilder(s);
      sb.reverse();//反转了,也可以手动反转
      return reverseEachword(sb);
    }

    public String reverseEachword(StringBuilder sb){
        int start=0;
        int end=1;//开始向后找到一个空格就是单词;
        int len=sb.length();
        while(start<len){
             while(end<len&&sb.charAt(end)!=' ') end++;
             //反转start~end-1
             reverseSingleWord(sb,start,end-1);
             start=end+1;
             end=start+1;
        }
        return sb.toString();
    }

    public void reverseSingleWord(StringBuilder sb,int start,int end){
                while(start<end){
                    char temp=sb.charAt(start);
                    sb.setCharAt(start,sb.charAt(end));
                    sb.setCharAt(end,temp);
                    start++;
                    end--;
                }
    }


    public String removeSpace(String s){
      //去除多余空格  
      int start=0;
      int end=s.length()-1;
      while(s.charAt(start)==' ') start++;
      while(s.charAt(end)==' ') end--;
      StringBuilder sb=new StringBuilder();
      for(int i=start;i<=end;i++){
          if(s.charAt(i)==' '&&sb.charAt(sb.length()-1)==' ');
          else sb.append(String.valueOf(s.charAt(i)));
      }
     return sb.toString();
    }
}

左旋字符串

字符串的左旋转操作是把字符串前面的若干个字符转移到字符串的尾部。请定义一个函数实现字符串左旋转操作的功能。比如，输入字符串"abcdefg"和数字2，该函数将返回左旋转两位得到的结果"cdefgab"。

示例 1：
输入: s = “abcdefg”, k = 2
输出: “cdefgab”

方法:
暴力:直接分开追加
双指针:花式反转

class Solution {
    public String reverseLeftWords(String s, int n) {
        //用stringbuilder先拼接n后面的东西,在拼接前面的东西
        StringBuilder sb = new StringBuilder();
        for(int i=n;i<s.length();i++){
            sb.append(s.charAt(i));
        }
        for(int i=0;i<n;i++){
            sb.append(s.charAt(i));
        }
        return sb.toString();
    }
}

//花式反转法则
class Solution {
    public String reverseLeftWords(String s, int n) {
       //反转整体
       //反转前0~n-1个,在反转n~length-1
       //最后反转整体
       StringBuilder sb =new StringBuilder(s);
       int len=sb.length();
        reverseString(sb,0,n-1);
        reverseString(sb,n,len-1);
      return sb.reverse().toString();   
    }

    public void reverseString(StringBuilder sb,int start,int end){
        while(start<end){
            char temp=sb.charAt(start);
            sb.setCharAt(start,sb.charAt(end));
            sb.setCharAt(end,temp);
            start++;
            end--;
        }
    }
}