代码随想录算法训练营第八天 | ● 344.反转字符串 ● 541. 反转字符串II ● 卡码网：54.替换数字 ● 151.翻转字符串里的单词 ● 卡码网：55.右旋转字符串

最新推荐文章于 2024-07-10 19:45:30 发布

努力学习的小许x

最新推荐文章于 2024-07-10 19:45:30 发布

阅读量835

点赞数 16

分类专栏：代码随想录算法训练营文章标签：算法数据结构

本文链接：https://blog.csdn.net/xuchenxi123/article/details/135465584

版权

代码随想录算法训练营专栏收录该内容

20 篇文章 0 订阅

订阅专栏

代码随想录算法训练营第八天

代码随想录

344.反转字符串

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

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

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

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

思路：这道题很简单，想到了用双指针的方法

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--;
        }
        //System.out.println(s);
    }

还有一种使用for循环

public void reverseString(char[] s) {
        for(int i =0;i<s.length/2;i++){
            char temp = s[i];
            s[i]=s[s.length-1-i];
            s[s.length-1-i]=temp;
        }
        System.out.println(s);
    }

541. 反转字符串II

给定一个字符串 s 和一个整数 k，从字符串开头算起, 每计数至 2k 个字符，就反转这 2k 个字符中的前 k 个字符。

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

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

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

题目的意思其实概括为每隔2k个反转前k个，尾数不够k个时候全部反转
注意审题：每隔2k个反转前k个
解法1

public String reverseStr(String s, int k) {
        char[] ch = s.toCharArray();
        for (int i = 0; i < s.length(); i += 2 * k) {
            int left = i;
            int right = Math.min(ch.length - 1, i + k - 1);

            while (left < right) {
                char temp = ch[left];
                ch[left] = ch[right];
                ch[right] = temp;
                left++;
                right--;
            }
        }
        return new String(ch);
}

解法2

public String reverseStr(String s,int k){
        char[] ch =s.toCharArray();
        for(int i = 0;i<s.length();i+= 2*k){
            if(i+k<=s.length()){
                reverseString(ch,i,i+k-1);
                continue;
            }
            reverseString(ch,i,ch.length-1);
        }

        return new String(ch);


    }

    public void reverseString(char[] str,int left,int right) {
        while(left<right){
            char temp = str[left];
            str[left]=str[right];
            str[right]=temp;
            left++;
            right--;
        }
    }

卡码网：54.替换数字

给定一个字符串 s，它包含小写字母和数字字符，请编写一个函数，将字符串中的字母字符保持不变，而将每个数字字符替换为number。

例如，对于输入字符串 “a1b2c3”，函数应该将其转换为 “anumberbnumbercnumber”。

对于输入字符串 “a5b”，函数应该将其转换为 “anumberb”

输入：一个字符串 s,s 仅包含小写字母和数字字符。

输出：打印一个新的字符串，其中每个数字字符都被替换为了number

样例输入：a1b2c3

样例输出：anumberbnumbercnumber

数据范围：1 <= s.length < 10000。

Java中 String是不可变类型，因此要使用StringBuilder（是可变类型）

public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        String s = sc.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.翻转字符串里的单词

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

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

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

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

思路：
1、删除首尾多余空格
2、删除中间多余空格
3、整体翻转
4、单个单词翻转

public String reverseWords(String s) {
        //删除首尾、中间多余空格
        StringBuilder sb = removeSpace(s);

        // 翻转整个字符串
        reverseString(sb,0,sb.length()-1);

        //翻转单个字符
        reverseStringWord(sb);

        return sb.toString();
    }

    public StringBuilder removeSpace(String s){
        StringBuilder sb = new StringBuilder();
        int start = 0;
        int end = s.length()-1;
        //删除首尾空格
        while(s.charAt(start)== ' ') start++;
        while(s.charAt(end)== ' ') end--;
        //删除中间多余空格
        while(start<=end){
            char c = s.charAt(start);
            if(c!=' ' || sb.charAt(sb.length()-1)!=' '){
                sb.append(c);
            }
            start++;
        }

        return sb;

    }

    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--;
        }
    }

    public void reverseStringWord(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;

        }

    }

卡码网：55.右旋转字符串

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

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

输入：输入共包含两行，第一行为一个正整数 k，代表右旋转的位数。第二行为字符串 s，代表需要旋转的字符串。

输出：输出共一行，为进行了右旋转操作后的字符串。

思路：使用整体反转+局部反转就可以实现反转单词顺序的目的。

public class Main {
 
    public static void main(String[] args) throws IOException {
 
        // 读取k
        int k = Reader.nextInt();
        // 读取字符串
        String s = Reader.nextLine();
        // 将字符串转化为字符数组
        char[] str = s.toCharArray();
 
        // 先反转整个字符串
        reverseString(str, 0, str.length-1);
        // 再反转原先的第二部分
        reverseString(str, 0, k-1);
        // 反转原先的第一部分
        reverseString(str, k, str.length-1);
 
        // 输出右旋转后的字符串
        PrintWriter out = new PrintWriter(System.out);
        out.println(new String(str));
        out.flush();    // 刷新快速输出流
 
    }
    // 相向双指针 实现字符串反转
    public static void reverseString(char[] str, int left, int right) {
        while (left < right) {
            str[left] ^= str[right];
            str[right] ^= str[left];
            str[left] ^= str[right];
            ++ left;
            -- right;
        }
    }
}

public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        int k = sc.nextInt();
        sc.nextLine();
        String s = sc.nextLine();
        char[] res = s.toCharArray();
        char[] ans = new char[res.length];
        for (int i = 0, j = res.length - k; j < res.length; j++, i++){
            ans[i] = res[j];
        }
        for (int i = k; i < res.length; i++){
            ans[i] = res[i - k];
        }
        String answer = new String(ans);
        System.out.println(answer);
    }