Day8--数据结构与算法（java)字符串

一，344.反转字符串

力扣题目链接

双指针思想，一个指向头，一个指向尾，两者不断向中间移动

class Solution {
    public void reverseString(char[] s) {
        int j=s.length-1;
     for(int i=0;i<s.length/2;i++,j--)
     {
         char temp=s[i];
         s[i]=s[j];
         s[j]=temp;
      
     }
    }
}

采用位运算： 

class Solution {
    public void reverseString(char[] s) {
        int j=s.length-1;
        int i=0;
     while(i<j)
     {
         s[i]^=s[j];
         s[j]^=s[i];
         s[i]^=s[j];
         i++;
         j--;
     }
    }
}

 s[i]^=s[j];//构造 a ^ b 的结果，并放在 a 中
        s[j]^=s[i];//将 a ^ b 这一结果再 ^ b ，存入b中，此时 b = a, a = a ^ b
        s[i]^=s[j]; //a ^ b 的结果再 ^ a ，存入 a 中，此时 b = a, a = b 完成交换

这个交换的过程，因为二制进中只有两个数值 (0和1)，所以实际上只是0变1，1变0 所以总结出来就是，交换两个数，就是它们的二进制数不一样的位数，只要各自取反 (0变1，1变0)就行了 如果两个数转换为二进制数的位数不一样，只要短的那个前面补0即可。

java不能直接用swap函数,会报错

swap(s[i],s[j]);

 

原因，查询java的API文档，可以看到只有一种swap方法，还是用在列表中的。 

 

二，541. 反转字符串II

力扣题目链接

其实在遍历字符串的过程中，只要让 i += (2 * k)，i 每次移动 2 * k 就可以了，然后判断是否需要有反转的区间。

因为要找的也就是每2 * k 区间的起点，这样写，程序会高效很多。

所以当需要固定规律一段一段去处理字符串的时候，要想想在在for循环的表达式上做做文章。

class Solution {
    public String reverseStr(String s, int k) {
     char ch[]=s.toCharArray();
     for(int i=0;i<ch.length;i+=2*k)
     {
         if(i+k<=ch.length)
         {
           reverse(ch,i,i+k-1);
           continue;
         }
         reverse(ch,i,ch.length-1);
     }
    return new String(ch);
    
    }
     public void reverse(char ch[],int i,int j)
    {
       while(i<j)
       {
           ch[i]^=ch[j];
           ch[j]^=ch[i];
           ch[i]^=ch[j];
           i++;
           j--;
       }
   
    }
}

三，题目：剑指Offer 05.替换空格

力扣题目链接

class Solution {
    public String replaceSpace(String s) {
    if(s==null||s.length()==0)
    {
      return s;
    }
    StringBuilder sb=new StringBuilder();
    for(int i=0;i<s.length();i++)
    {
    if(s.charAt(i)==' ')
    {
        sb.append("  ");//sb里面存放的是扩充的部分
    }
    }
    if(sb.length()==0)
    {
        return s; //若是没有空格直接返回
    }

 //如果没有空格直接返回
    
     int left=s.length()-1;
     s+=sb.toString();//扩充部分加上原来的数组
     int right=s.length()-1;
     char [] chars=s.toCharArray();
     while(left>=0)
     {
      if(chars[left]==' ')
      {
       chars[right--]='0';
       chars[right--]='2';
       chars[right]='%';
      }
      else
      {
      chars[right]=chars[left];
      }
      left--;
      right--;
     }
     return new String(chars);
    }
}

class Solution {
    public String replaceSpace(String s) {
    if(s==null)
    {
        return null;
    }
    StringBuilder sb=new StringBuilder();
    for(int i=0;i<s.length();i++)
    {
        if(s.charAt(i)==' ')
        {
            sb.append("%20");
        }
        else
        {
          sb.append(s.charAt(i));
        }
    }
    return sb.toString();
    }
}

 其中应该注意的方法

 StringBuilder sb=new StringBuilder();
 sb.append("  ");//sb里面存放的是扩充的部分

  s+=sb.toString();//把StringBuilder对象转为String

char[] chars = s.toCharArray();//把字符串转为字符数组

s.charAt(i)//获取字符串里的字符

StringBuilder对象

字符串String用法：

151.翻转字符串里的单词

力扣题目链接

class Solution {
   /**
     * 不使用Java内置方法实现
     * <p>
     * 1.去除首尾以及中间多余空格
     * 2.反转整个字符串
     * 3.反转各个单词
     */
    public String reverseWords(String s) {
        // System.out.println("ReverseWords.reverseWords2() called with: s = [" + s + "]");
        // 1.去除首尾以及中间多余空格
        StringBuilder sb = removeSpace(s);
        // 2.反转整个字符串
        int start=0;
        int end=sb.length()-1;
        reverseString(sb, start,end);
        // 3.反转各个单词
        reverseEachWord(sb);
        return sb.toString();
    }

    private StringBuilder removeSpace(String s) {
        // System.out.println("ReverseWords.removeSpace() called with: s = [" + s + "]");
        int start = 0;
        int end = s.length() - 1;
        while (s.charAt(start) == ' ') start++;
        while (s.charAt(end) == ' ') end--;
        StringBuilder sb = new StringBuilder();
        while (start <= end) {
            char c = s.charAt(start);
            if (c != ' ' || sb.charAt(sb.length() - 1) != ' ') {
                sb.append(c);
            }
            start++;
        }
        // System.out.println("ReverseWords.removeSpace returned: sb = [" + sb + "]");
        return sb;
    }

    /**
     * 反转字符串指定区间[start, end]的字符
     */
    public void reverseString(StringBuilder sb, int start, int end) {
        // System.out.println("ReverseWords.reverseString() called with: sb = [" + sb + "], start = [" + start + "], end = [" + end + "]");
        
        while (start < end) {
            char temp = sb.charAt(start);
            sb.setCharAt(start, sb.charAt(end));
            sb.setCharAt(end, temp);
            start++;
            end--;
        }
        
        

        // System.out.println("ReverseWords.reverseString returned: sb = [" + sb + "]");
    }

    private void reverseEachWord(StringBuilder sb) {
        int start = 0;
        int end = 1;
        int n = sb.length();
        while (start < n) {
            while (end < n && sb.charAt(end) != ' ') {
                end++;
            }
            reverseString(sb, start, end - 1);
            start = end + 1;
            end = start + 1;
        }
    }
}

​​​​​​​

 

charAt出现在这些类中 

setCharAt 

 

题目：剑指Offer58-II.左旋转字符串

力扣题目链接

class Solution {
    public String reverseLeftWords(String s, int n) {
        int len=s.length();
        StringBuilder sb=new StringBuilder(s);
        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--;
            }
        }
}