代码随想录算法营|字符串

1. 字符串类和数组类的思路上区别不大，主要是在不一样的语言

题目一：反转字符串

1. 题目：写一个函数反转给定的字符串数组

2. 

public static void reverseString(char[] s) {
        int left=0,right=s.length-1;
        while(left<=right){
            char temp=s[left];
            s[left]=s[right];
            s[right]=temp;
            left++;
            right--;
        }
    }

题目二：反转字符串||

1. 题目：

2. 思路：

（1）因为要找前2k个，所以可以for(int i=0; i<s.length;i+=2*k) 2k个个数的进行查找

（2）因为题目给的是string，所以对string直接进行操作是错误的，例如：

public void reverse(String s,int left,int right){
        while(left<right){
            char temp=s.charAt(left);
            s.charAt(left)=s.charAt(right);//错误的
            s.charAt(right)=temp;
        }
    }

所以可以将string转化为char数组s.toCharArray()，或者用StringBuiledr、StringBuffer

（3）  int end = Math.min(ch.length - 1,start + k - 1); 定义end的位置

3. 代码

public String reverseStr(String s, int k) {
        char[] ch = s.toCharArray();
        for(int i = 0;i < ch.length;i += 2 * k){
            int start = i;
            // 判断尾数够不够k个来取决end指针的位置
            int end = Math.min(ch.length - 1,start + k - 1);
            while(start < end){
                
                char temp = ch[start];
                ch[start] = ch[end];
                ch[end] = temp;

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

题目三：替换数字

替换数字 | 代码随想录 (programmercarl.com)

题目四：反转字符串里的单词

1. 示例 1：输入: "the sky is blue"；输出: "blue is sky the"且多余的空格也要删除掉

2. 思路

（1）先将字符串整个进行翻转，然后再把每个单词进行翻转

（2）删除多余空格同时还保留单词之间的一个空格：用双指针的方法，O(N)，快指针获取符合题目的字母，慢指针是指向现在已经更新到哪里

（3）这个方法用的是从后往前遍历

public String reverseWords(String s) {
        char[] oldarray=s.toCharArray();//旧字符串s
        char[] newarray=new char[s.length()+1];//新字符串，+1是因为最后会有个空格
        int newpos=0;//新字符串数组的头
        int i=s.length()-1;//从后往前
        while(i>=0){
            while(i>=0 && oldarray[i]==' ')i--;//最后的空格删除掉
            int right=i;//最后一个单词的最后一个字母
            while(i>=0 && oldarray[i]!=' ')i--;//此时i是空格
            for(int j=i+1;j<=right;j++){//j=i+1所以就是从单词的第一个字母开始
                newarray[newpos++]=oldarray[j];
                if(j==right)newarray[newpos++]=' ';//??不懂为什么j==right
            }
        }
        if(newpos==0)return " ";
        else {
            return new String(newarray,0,newpos-1);//每次都会增加一个空格
        }

    }

题目五：右旋转字符串

1. 字符串的右旋转操作是把字符串尾部的若干个字符转移到字符串的前面。给定一个字符串 s 和一个正整数 k，请编写一个函数，将字符串中的后面 k 个字符移到字符串的前面，实现字符串的右旋转操作。

例如，对于输入字符串 "abcdefg" 和整数 2，函数应该将其转换为 "fgabcde"。

2. 思路

（1）先都从0到最后一个reverse，再分别reverse 0到n-1，n到最后一个字母

（2）因为不能直接在String上操作，所以需要在函数中转化为char数组进行翻转，最后return new String(ch)

import java.util.Scanner;

public class Main{
    public static void main (String[] args) {
        Scanner sc=new Scanner(System.in);
        int n= Integer.parseInt(sc.nextLine());
        String s =sc.nextLine();
        
        s=reverse(s,0,s.length()-1);
        s=reverse(s,0,n-1);
        s=reverse(s,n,s.length()-1);
        
        System.out.println(s);
    }
    
    public static String reverse(String s,int start,int end){
        char[] ch=s.toCharArray();
        while(start<end){
            char temp=ch[start];
            ch[start]=ch[end];
            ch[end]=temp;
            start++;
            end--;
        }
        return new String(ch);   
    }
}

（3）或者在主函数中将string转成ch数组，进行反转

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 - 1);  //反转整个字符串
        reverseString(chars, 0, n - 1);  //反转前一段字符串，此时的字符串首尾尾是0,n - 1
        reverseString(chars, n, len - 1);  //反转后一段字符串，此时的字符串首尾尾是n,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--;
        }
    }
}