【力扣刷题——字符串】附力扣链接、题目描述、解题方法及代码（344、541、剑指Offer05、151、剑指 Offer58、28、459）后续再补充

😀如果对你有帮助的话😊
🌺为博主点个赞吧 👍
👍点赞是对博主最大的鼓励😋
💓爱心发射~💓

344. 反转字符串——简单

力扣

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

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

示例 1：

输入：s = ["h","e","l","l","o"]
输出：["o","l","l","e","h"]

示例 2：

输入：s = ["H","a","n","n","a","h"]
输出：["h","a","n","n","a","H"]

方法一：双指针

class Solution {
    public void reverseString(char[] s) {
        // 双指针
        int len = s.length;
        for(int l=0,r=len-1; l<r; ++l,--r){
            char temp = s[l];
            s[l] = s[r];
            s[r] = temp;
        }
        
    }
}

541. 反转字符串 II——简单

力扣

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

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

示例 1：

输入：s = "abcdefg", k = 2
输出："bacdfeg"

示例 2：

输入：s = "abcd", k = 2
输出："bacd"

双指针

class Solution {
    public String reverseStr(String s, int k) {
        // for循环，每次从改建交换的位置开始
        // 下一个初始值间隔2k
        char[] cs = s.toCharArray();  // toCharArray() 方法将字符串转换为字符数组
        int len = s.length();
        for(int i=0; i<len; i=i+2*k){
            int r = i + k -1;
            reverse(cs, i, Math.min(r,len-1));
        }
        return String.valueOf(cs);   }

    // 交换位置方法
    void reverse(char[] cs, int l, int r){
        while(l<r){
            char b = cs[l];
            cs[l] = cs[r];
            cs[r] = b;
            ++l;
            --r;
        }
    }
}

剑指 Offer 05. 替换空格——简单

力扣

请实现一个函数，把字符串 s 中的每个空格替换成"%20"。

示例 1：

输入：s = "We are happy."
输出："We%20are%20happy."

方法一：遍历添加

class Solution {
    public String replaceSpace(String s) {
        // 将字符串转换为数组
        StringBuilder res = new StringBuilder();
        // 将数组换为字符串
        for(Character c : cs){
            if(c == ' '){
                res.append("%20");
            }else{
                res.append(c);
            }
        }
        return res.toString();
    }
}

151. 颠倒字符串中的单词

力扣

给你一个字符串 s ，颠倒字符串中 单词 的顺序。

单词 是由非空格字符组成的字符串。s 中使用至少一个空格将字符串中的 单词 分隔开。

返回 单词 顺序颠倒且 单词 之间用单个空格连接的结果字符串。

注意：输入字符串 s中可能会存在前导空格、尾随空格或者单词间的多个空格。返回的结果字符串中，单词间应当仅用单个空格分隔，且不包含任何额外的空格。

示例 1：

输入：s = "the sky is blue"
输出："blue is sky the"

示例 2：

输入：s = "  hello world  "
输出："world hello"
解释：颠倒后的字符串中不能存在前导空格和尾随空格。

示例 3：

输入：s = "a good   example"
输出："example good a"
解释：如果两个单词间有多余的空格，颠倒后的字符串需要将单词间的空格减少到仅有一个。
 

提示：

• 1 <= s.length <= 104
• s 包含英文大小写字母、数字和空格 ’ ’
• s 中 至少存在一个 单词

方法一：使用语言特性

class Solution {
    // 方法一：使用语言特性
    public String reverseWords(String s) {
        // 拆分字符串split     翻转字符串reverse     拼接字符串join
        // 去掉空白字符 trim
        s = s.trim();
        // 正则匹配连续的空白字符作为分隔符分割
        //  Arrays.asList 该方法是将数组转化成List集合的方法。
        // \\s+ 正则表达式
        List<String> wordList = Arrays.asList(s.split("\\s+"));
        Collections.reverse(wordList);
        return String.join(" ",wordList);

    }
}

方法二：双端队列

class Solution {
    public String reverseWords(String s) {
        /*
            1、删除左边空字符串
            2、删除右边空字符串
            3、循环--
                - 当单词长度不为0 ， 字符到空格的时候，将单词存到队列
                - 字符不为空，存到单词中
        */
        int le = 0, ri = s.length() - 1;
        while(le<=ri && s.charAt(le)==' '){
            ++le;
        }
        while(le<=ri && s.charAt(ri)==' '){
            --ri;
        }
        Deque<String> d = new ArrayDeque<String>();   //创建ArrayDeque双端队列
        StringBuilder word = new StringBuilder();   //适用于单线程下在字符串缓冲区进行大量操作
        while(le<=ri){
            char cc = s.charAt(le);
            if((word.length() != 0) && (cc == ' ')){
                d.offerFirst(word.toString()); // 将单词 push 到队列的头部
                word.setLength(0); 
                //toString() 方法用于返回以一个字符串表示的 Number 对象值
            }else if(cc != ' '){
                word.append(cc);
            }
            ++le;
        }
        d.offerFirst(word.toString());
        // join--将一个数组或者List的各项通过分隔符连接成字符串
        return String.join(" ",d);

    }
}

剑指 Offer 58 - II. 左旋转字符串——简单

力扣

字符串的左旋转操作是把字符串前面的若干个字符转移到字符串的尾部。请定义一个函数实现字符串左旋转操作的功能。比如，输入字符串"abcdefg"和数字2，该函数将返回左旋转两位得到的结果"cdefgab"。

示例 1：

输入: s = "abcdefg", k = 2
输出: "cdefgab"

示例 2：

输入: s = "lrloseumgh", k = 6
输出: "umghlrlose"

方法一：字符串切片

class Solution {
    public String reverseLeftWords(String s, int n) {
        //方法一：字符串切片
        return s.substring(n, s.length()) + s.substring(0, n);
    }
}

方法二：列表遍历拼接

class Solution {
    public String reverseLeftWords(String s, int n) {
        //方法二：列表遍历拼接
        StringBuilder res = new StringBuilder();
        for(int i=n; i<s.length(); ++i){
            res.append(s.charAt(i));
        }
        for(int i=0; i<n; ++i){
            res.append(s.charAt(i));
        }
        return res.toString();

    }
}

方法三：字符串遍历拼接

class Solution {
    public String reverseLeftWords(String s, int n) {
        // 方法三：字符串遍历拼接
        // 先存后边字符串，再存前边
        String res = "";
        for(int i=n; i<s.length(); ++i){
            res += s.charAt(i);
        }
        for(int i=0; i<n; ++i){
            res += s.charAt(i);
        }
        return res;
    }
}

28. 实现 strStr()——简单

力扣

实现 strStr() 函数。

给你两个字符串 haystack 和 needle ，请你在 haystack 字符串中找出 needle 字符串出现的第一个位置（下标从 0 开始）。如果不存在，则返回 -1 。

说明：

当 needle 是空字符串时，我们应当返回什么值呢？这是一个在面试中很好的问题。

对于本题而言，当 needle 是空字符串时我们应当返回 0 。这与 C 语言的 strstr() 以及 Java 的 indexOf() 定义相符。

示例 1：

输入：haystack = "hello", needle = "ll"
输出：2

示例 2：

输入：haystack = "aaaaa", needle = "bba"
输出：-1

提示：

• 1 <= haystack.length, needle.length <= 104
• haystack 和 needle 仅由小写英文字符组成

方法一：暴力匹配

class Solution {
    public int strStr(String haystack, String needle) {
        // 将字符串换数组
        // 找第一个位置，看字符串是否相符
        // 不符找下一个位置
        int h = haystack.length(), n = needle.length();
        char[] a = haystack.toCharArray(), b = needle.toCharArray();
        for(int i=0; i<= h-n; ++i){
            // 判断第一个字符是否相同，相同返回下标，不同继续循环
            // 用d的长度来判断字符串是否相同
            int c = i, d = 0;
            while(d < n && a[c] == b[d]){
                // 若第一个字符相同，继续判断下一个位置
                c++;
                d++;
            }
            if(d == n) return i;
        }
        return -1;
    }
}

方法二：KMP 算法

class Solution {
    public int strStr(String haystack, String needle) {
        // 判断空字符串
        if(needle.isEmpty()) return 0;
        // 将字符串换数组
        // 加空格
        int h = haystack.length(), n = needle.length();
        haystack = " " + haystack;  // 原串
        needle = " " + needle;      // 匹配串
        char[] a = haystack.toCharArray(), b = needle.toCharArray();

        // 构建next数组
        int[] next = new int[n+1];
        // 两个指针 前i 后j  i从2，j从1
        // 判断 b[i]=b[j+1]是否相等 相等 next[i]=j  不相等j=next[j]
        // 
        for(int i=2,j=0; i<=n; ++i){
            while(j>0 && b[i]!=b[j+1]) j=next[j]; 
            if(b[i] == b[j+1]) j++;
            next[i] = j;
        }

        // 匹配过程 
        //
        for(int i=1,j=0; i<=h; ++i){
            while(j>0 && a[i] != b[j+1]) j=next[j];
            if(a[i]==b[j+1]) j++;
            if(j==n) return i-n;
        }
        return -1;
    }
}

459. 重复的子字符串——简单

力扣

给定一个非空的字符串 s ，检查是否可以通过由它的一个子串重复多次构成。

示例 1:

输入: s = "abab"
输出: true
解释: 可由子串 "ab" 重复两次构成。

示例 2:

输入: s = "aba"
输出: false

示例 3:

输入: s = "abcabcabcabc"
输出: true
解释: 可由子串 "abc" 重复四次构成。 (或子串 "abcabc" 重复两次构成。)
 

提示：

• 1 <= s.length <= 104
• s 由小写英文字母组成

方法一：枚举

class Solution {
    public boolean repeatedSubstringPattern(String s) {
        // 第一次循环——循环每个位置，是否为字符串长度整除
        // 只循环字符串一半就行
        //    第二次循环——判断j以后字符 每位都对应上
        //      判断j与首位是否相同，相同换下一位i
        int len = s.length();
        for(int i=1; i*2<=len; ++i){
            if(len % i == 0){
                boolean blue = true;
                for(int j=i; j<len; ++j){
                    if(s.charAt(j)!=s.charAt(j-i)){
                        blue = false;
                        break;
                    }
                }
                if(blue){
                    return true;
                }
            }
        }
        return false;
    }
}

678. 有效的括号字符串

力扣

栈

class Solution {
    public boolean checkValidString(String s) {
        /*

        */
        Deque<Integer> leftStack = new LinkedList<Integer>();
        Deque<Integer> asteriskStack = new LinkedList<Integer>();
        int n = s.length();
        for(int i=0; i<n; i++){
            char c = s.charAt(i);
            if(c == '('){
                leftStack.push(i);
            }else if(c == '*'){
                asteriskStack.push(i);
            }else{
                if(!leftStack.isEmpty()){
                    leftStack.pop();
                }else if(!asteriskStack.isEmpty()){
                    asteriskStack.pop();
                }else{
                    return false;
                }
            }
        }
        while(!leftStack.isEmpty() && !asteriskStack.isEmpty()){
            int leftIndex = leftStack.pop();
            int asteriskIndex = asteriskStack.pop();
            if(leftIndex > asteriskIndex){
                return false;
            }
        }
        return leftStack.isEmpty();
    }
}