代码随想录打卡DAY8

 344.反转字符串 

很简单的双指针运用，可惜java里面没有swap

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

541. 反转字符串II

      主要是把字符串转化为字符数组，char[] arr = s.toCharArray();然后区间设定为2k，剩余要是大于等于k小于2k就反转前k个，都是进入if 里进行反转前k个 所以实际上不需要判断i+2k小于数组长度，后面的就是剩余字符小于k个情况,写个if,else也是可以的

class Solution {
    public String reverseStr(String s, int k) {
        char[] arr = s.toCharArray();
        for (int i = 0; i < arr.length; i += (2 * k)) {
            // 1. 每隔 2k 个字符的前 k 个字符进行反转
            // 2. 剩余字符小于 2k 但大于或等于 k 个，则反转前 k 个字符
            if (i + k <= arr.length) {
                reverse(arr, i, i + k - 1);
                continue;
            }
            // 3. 剩余字符少于 k 个，则将剩余字符全部反转。
            reverse(arr, i, arr.length - 1);
        }
        return new String(arr);
    }
    public void reverse(char[] s, int start, int end) {
        while (start < end) {
            char temp = s[start];
            s[start] = s[end];
            s[end] = temp;
            start++;
            end--;
        }   
    }
}

替换数字

java创建一个stringbuilder类来更改数组长度后面调用append

import java.util.Scanner;

class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        String s = in.nextLine();
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < s.length(); i++) {
            if (Character.isDigit(s.charAt(i))) {
                sb.append("number");
            }else sb.append(s.charAt(i));
        }
        System.out.println(sb);
    }
}

151.翻转字符串里的单词

主要还是思路就是先去除空格，然后反转整个字符串然后反转各个单词，详情看注释

class Solution {
    public String reverseWords(String s) {
        StringBuilder sb = removeSpace(s);
        // 2.反转整个字符串
        reverseString(sb, 0, sb.length() - 1);
        // 3.反转各个单词
        reverseEachWords(sb);
        return sb.toString();
    }

    private StringBuilder 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();
        while (start <= end) {
            //这里从start开始循环时小于等于end代表已经去除前后多余空格
            char c = s.charAt(start);
            /*这里的sb.charAt(sb.length() - 1) != ' '，
            sb是新建的stringbuilder对象，所以当连续的两个空格,
            第一个被加入到最后，
            第二个空格进行判断发生sb的最后一格是空格就无法加入*/
            if (c != ' ' || sb.charAt(sb.length() - 1) != ' ' ) {
                sb.append(c);
            }
            start++;
        }
        // System.out.println("ReverseWords.removeSpace returned: sb = [" + sb + "]");
        return sb;
    }



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

    private void reverseEachWords(StringBuilder s){
        int start=0;
        int end=1;
        int n=s.length();
        while(start<n){
            while(end <n && s.charAt(end) != ' '){
                end++;                
            }
            reverseString(s,start,end-1);
            start=end+1;//此时start已经在下一个单词的开头位置了
            end=start+1;//end就在start后面一格
            
        }
    }
}

右旋字符串

思路就是前一段反转，后一段反转，最后整个反转，用两只手比划一下就可以发现反转的目的就是让右边字符串的尾部与左边字符串头部连接

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int n = Integer.parseInt(in.nextLine());
        String s = in.nextLine();

        int len = s.length();  //获取字符串长度
        char[] chars = s.toCharArray();
        reverseString(chars, 0, len - n - 1);  //反转前一段字符串，此时的字符串首尾是0,len - n - 1
        reverseString(chars, len - n, len - 1);  //反转后一段字符串，此时的字符串首尾是len - n,len - 1
        reverseString(chars, 0, len - 1);  //反转整个字符串

        System.out.println(chars);

    }

    public static void reverseString(char[] ch, int start, int end) {
        //异或法反转字符串，参照题目 344.反转字符串的解释
        while (start < end) {
            ch[start] ^= ch[end];
            ch[end] ^= ch[start];
            ch[start] ^= ch[end];
            start++;
            end--;
        }
    }
}