代码随想录算法训练营第八天 | 344.反转字符串，541. 反转字符串II，剑指Offer 05.替换空格，151.翻转字符串里的单词，剑指Offer58-II.左旋转字符串

最新推荐文章于 2024-10-02 23:40:03 发布

soul_surfer

最新推荐文章于 2024-10-02 23:40:03 发布

阅读量84

点赞数

文章标签：算法 leetcode 数据结构

本文链接：https://blog.csdn.net/soul_surfer/article/details/129701770

版权

LeetCode 344.反转字符串

题目链接：344.反转字符串

解题思路

分析题目：

不要给另外的数组分配额外的空间，你必须原地修改输入数组、使用 O(1) 的额外空间解决这一问题。
s[i] 都是 ASCII 码表中的可打印字符

思路一（双指针法）

因为题目需要我们直接修改原数组，我们采用双指针法（left,right）,取一个临时的值作为左右两边交换的中间量，做完调换后，left和right向中心移动，直到left >= right,输出数组。
在这里插入图片描述

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

LeetCode 541. 反转字符串II

题目链接：反转字符串II

解题思路

分析题目可得：

从字符串开头算起，每计数至 2k 个字符，就反转这 2k 字符中的前 k 个字符
如果剩余字符少于 k 个，则将剩余字符全部反转。
如果剩余字符小于 2k 但大于或等于 k 个，则反转前 k 个字符，其余字符保持原样。

思路一（双指针）

我们发现，只有到最后2k部分时会出现两种反转方式，前面的反转方式是一样的，每2*k次对前面k部分进行一次反转，后面两种反转的方式不同的地方在于反转结束的位置，一个位于k，另一个位于最后一个数的位置。

初始版

class Solution {
    public String reverseStr(String s, int k) {
        int temp = s.length() % (2 * k);
        int n = s.length() / (2 * k);
        char[] c = s.toCharArray();
        if(n > 0){
            for(int i = 0; i < s.length() - temp;){
                int left = i;
                int right = left + k -1;
                while(left < right){
                    char mid = c[left];
                    c[left] = c[right];
                    c[right] = mid;
                    left++;
                    right--;
                }
                i = i + 2 * k;
            }
        }
        if(temp >= k){
            int left = n * 2 * k;
            int right = left + k - 1;
            while(left < right){
                char mid = c[left];
                c[left] = c[right];
                c[right] = mid;
                left++;
                right--;
            }
        }else{
            int left = n * 2 * k;
            int right = s.length() - 1;
            while(left < right){
                char mid = c[left];
                c[left] = c[right];
                c[right] = mid;
                left++;
                right--;
            }
        }
        String t = String.valueOf(c);
        return t;
    }
}

进阶版

我们可以不需要将其分开进行反转，我们只要确定反转的开始和结束，开始位置可以通过遍历得到，而结束位置只有在最后的地方不一样，我们只要比较最后开始的位置+k-1与最后一个数的位置进行比较，取里面最小的值为结束位置。

class Solution {
    public String reverseStr(String s, int k) {
        char[] c = s.toCharArray();
        for(int i = 0; i < s.length(); i += 2*k){
            int start = i;
            int end = Math.min(s.length() - 1, start + k - 1);
            while(start < end){
                char mid = c[start];
                c[start] = c[end];
                c[end] = mid;
                start++;
                end--;
            }
        }
        return new String(c);
    }
}

思路二（库函数reverse的使用）

我们可以将2k部分截取为两端，前k部分和后k部分（start—mid，mid—end）.
库函数reverse（int start，int end），我们只要将start和end确定就可以直接反转，但是由题可知，start每次都是在2k部分的开头，而end存在两种情况就是如果start +ｋ小于len，end = len,如果大于或等于，则为end = mid；。
如果在截取的后面存在字符（mid < end），我们要将其直接加入到字符串后面。
StringBuffer 类是可变字符串类，创建 StringBuffer 类的对象后可以随意修改字符串的内容。追加字符串：StringBuffer 对象.append(String str)，替换字符：StringBuffer 对象.setCharAt(int index, char ch);反转字符串：StringBuffer 对象.reverse();删除字符串：1.deleteCharAt() 方法用于移除序列中指定位置的字符：StringBuffer 对象.deleteCharAt(int index);2.delete() 方法用于移除序列中子字符串的字符：StringBuffer 对象.delete(int start,int end);
String.substring(int beginIndex, int endIndex);截取一段字符串。

class Solution {
    public String reverseStr(String s, int k) {
        StringBuffer res = new StringBuffer();
        int start = 0;
        int len = s.length();
        while(start < len){
            StringBuffer temp = new StringBuffer();
            int mid = start + k > len ? len : start + k;
            int end = start + (2 * k) > len ? len : start + 2*k;
            temp.append(s.substring(start, mid));
            res.append(temp.reverse());
            if(mid < end){
                res.append(s.substring(mid, end));
            }
            start += 2 * k;
        }
        return res.toString();
    }
}

LeetCode 剑指Offer 05.替换空格

题目链接：剑指Offer 05.替换空格

解题思路

分析题目可得：
1.把字符串 s 中的每个空格替换成"%20"，空格长度为1，而"%20"长度为3，所以如果在原字符串进行修改需要扩容。

思路一（StringBuffer的使用）

StringBuffer是一个长度可以改变的字符串，而其库函数中append直接字符串后追加字符串。设一个新的StringBuffer字符串，我们可以遍历s字符串，如果字符不为空，就直接追加在StringBuffer字符串后面，如果为空，就将“%20”追加在StringBuffer字符串后面，遍历完将StringBuffer.toString转换为

class Solution {
    public String replaceSpace(String s) {
        if(s == null){
            return s;
        }
        StringBuffer res = new StringBuffer();
        char[] c = s.toCharArray();
        for(int i = 0; i < s.length(); i++){
            if(c[i] != ' '){
                res.append(c[i]);
            }else{
                res.append("%20");
            }
        }
        return res.toString();
    }
}

思路二（双指针法）

先遍历字符串，查询空格的个数，在对字符串进行扩容,然后使用两个指针一个从原本的字符串最后一个位置开始遍历，而另一个指针位于扩容后字符串的最后一个位置，如果前一个字符串遍历时，不为空格就直接将该位置的字符移向后一个指针的位置，同时往前移位置，如果为空，后面指针移动的同时将"%20"加入，遍历完输出s。

class Solution {
    public String replaceSpace(String s) {
        if(s == null || s.length() <= 0){
            return s;
        }
        StringBuffer t = new StringBuffer();
        for(int i = 0; i < s.length(); i++){
            if(s.charAt(i) == ' '){
                t.append("  ");
            }
        }
        int l = s.length() - 1;
        s = s + t.toString();
        char[] c = s.toCharArray();
        int r = s.length() - 1;
        while(l >= 0){
            if(c[l] == ' '){
                c[r--] = '0';
                c[r--] = '2';
                c[r] = '%';
            }else{
                c[r] = c[l];
            }
            l--;
            r--;
        }
        return new String(c);
    }
}

LeetCode 151.翻转字符串里的单词

题目链接：151.翻转字符串里的单词

解题思路

分析题目可得：

s 中使用至少一个空格将字符串中的单词分隔开，输入字符串 s中可能会存在前导空格、尾随空格或者单词间的多个空格，s中单词间的空格可能不唯一，开头和结尾都可能有空格。
返回单词顺序颠倒且单词之间用单个空格连接的结果字符串。

思路一（双指针+StringBuffer的使用）

分析题目我们可以从以下三个步骤来结局这个问题：

移除多余空格
将整个字符串反转
将每个单词反转

class Solution {
    public String reverseWords(String s) {
        StringBuffer res = new StringBuffer();
        res = removeSpace(s);
        reverseString(res, 0, res.length() - 1);
        reverseEachWord(res);
        return res.toString();
    }

    public StringBuffer removeSpace(String s){
        int left = 0;
        int right = s.length() - 1;
        while(s.charAt(left) == ' '){
            left++;
        }
        while(s.charAt(right) == ' '){
            right--;
        }
        StringBuffer res = new StringBuffer();
        while(left <= right){
            if(s.charAt(left) != ' ' || (s.charAt(left) == ' '&& s.charAt(left - 1) != ' ')){
                res.append(s.charAt(left));
            }
            left++;
        }
        return res;
    }

    public void reverseString(StringBuffer res, int start, int end){
        while(start < end){
            char temp = res.charAt(start);
            res.setCharAt(start, res.charAt(end));
            res.setCharAt(end, temp);
            start++;
            end--;
        }
    }
    public void reverseEachWord(StringBuffer res){
        int start = 0;
        int end = 1;
        while(start < res.length()){
            while(end < res.length() && res.charAt(end) != ' '){
                end++;
            }
            reverseString(res, start, end - 1);
            start = end + 1;
            end = start + 1;
        }
    }
}

思路二（创建新字符数组填充）

我们可以设置一个新的char数组，我们从右边开始遍历，如果遍历位置为空格，则继续向下移动，移动到不是空格的位置，将这个点记为单词的最右点，在向下遍历到为空格的位置，从这个位置的前一个点开始遍历到单词的最右点，将每个点的字母装入新的char数组中，然后循环遍历上面过程，最后将新的char数组转变为String输出。

class Solution {
    public String reverseWords(String s) {
        char[] c = s.toCharArray();
        char[] res = new char[s.length() + 1];
        int resLen = 0;
        int i = s.length() - 1;
        while(i >= 0){
            while(i >= 0 && c[i] == ' '){i--;}
            int right = i;
            while(i >= 0 && c[i] != ' '){i--;}
            for(int j = i + 1; j <= right; j++){
                res[resLen++] = c[j];
                if(j == right){
                    res[resLen++] = ' ';
                }
            }
        }
        if(resLen == 0){
            return "";
        }else{
            return new String(res, 0, resLen - 1);
        }
        
    }
}

LeetCode 剑指Offer58-II.左旋转字符串

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

解题思路

分析题目可得：

把字符串前面的若干个字符转移到字符串的尾部。

思路一（StringBuffer的使用）

我们可以将字符串分为两个部分，要移往后面的部分和移往前面的部分，我们可以直接将两个部分内部反转，然后再将整个字符串全部反转过来。
在这里插入图片描述

class Solution {
    public String reverseLeftWords(String s, int n) {
        StringBuffer res = new StringBuffer(s);
        reverseString(res, 0, n - 1);
        reverseString(res, n, s.length() - 1);
        return res.reverse().toString();
    }
    public void reverseString(StringBuffer res, int start, int end){
        while(start < end){
            char temp = res.charAt(start);
            res.setCharAt(start, res.charAt(end));
            res.setCharAt(end, temp);
            start++;
            end--;
        }
    }
}

思路二（双指针）

与思路一由异曲同工之妙，先整个字符串反转，再反转前面的，最后反转后面 n 个，通过双指针实现反转。

class Solution {
    public String reverseLeftWords(String s, int n) {
        char[] c = s.toCharArray();
        reverseString(c, 0, s.length() - 1);
        reverseString(c, 0, s.length() - n - 1);
        reverseString(c, s.length() - n, s.length() - 1);
        return new String(c);
    }
    public void reverseString(char[] c, int start, int end){
        while(start < end){
            char temp = c[start];
            c[start] = c[end];
            c[end] = temp;
            start++;
            end--;
        }
    }
}

soul_surfer

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
复制链接

分享到 QQ

分享到新浪微博

扫一扫