力扣刷题篇之字符串1

系列文章目录

---

目录

系列文章目录

前言

一、字符

 二、回文串的定义

三、公共前缀

四、单词 

五、字符串的反转

总结

---

前言

 本系列是个人力扣刷题汇总，本文是字符串。刷题顺序按照[力扣刷题攻略] Re：从零开始的力扣刷题生活 - 力扣（LeetCode）

---

一、字符

520. 检测大写字母 - 力扣（LeetCode）

这题记下ASCII码表

可见A:65          a:97

代码还是很简单

如果前两个字符中有一个是小写，那么之后都要是小写，否则，即前两个字符都是大写，之后的都要大写，不满足就都返回false。

class Solution {
    public boolean detectCapitalUse(String word) {
        if (word.length() == 1) return true;
        if (word.charAt(0) > 90 || word.charAt(1) > 90) {
            for (int j = 1; j < word.length(); ++j) {
                if (word.charAt(j) < 97) return false;
            }
        } else {
            for (int i = 1; i < word.length(); ++i) {
                if (word.charAt(i) > 90) return false;
            }
        }
        return true;
    }
}

 二、回文串的定义

125. 验证回文串 - 力扣（LeetCode）

 checkchar函数用于处理字符，如果输入的字符是数字或者大写字母，那么返回输入的不变，如果是小写字母就换成对应的大写，剩下的其余一切都变成‘-’。

这里主要采用双指针的方法，左指针和右指针的值对比，但凡有一个不一样都false，直到比较到字符串中间位置还一一相等，则true。

class Solution {
    public boolean isPalindrome(String s) {
        int left = 0, right = s.length()-1;
        while(left < right){
            char l = checkChar(s.charAt(left));
            char r = checkChar(s.charAt(right));
            if(l == '-'){
                left++;
                continue;
            }
            if(r == '-'){
                right--;
                continue;
            }
            if(l==r){
                left++;
                right--;
                continue;
            }
            return false;
        }
        return true;
    }
    public static char checkChar(char c){
        if(c >='0' && c<='9') return c;
        if(c>='a' && c<='z') return (char)(c-'a'+'A');
        if(c>='A' && c<='Z') return c;
        return '-';
    }
}

三、公共前缀

14. 最长公共前缀 - 力扣（LeetCode）

这个之前也做过

// class Solution {
//     public String longestCommonPrefix(String[] strs) {
//         String s = strs[0];
//         int t = 0;
//         for(int i = 1; i< strs.length; i++){
//             for(int j = 0; j < Math.min(s.length(), strs[i].length()); j++){
//                 if(s.charAt(j) == strs[i].charAt(j)){
//                     t++;
//                 }else {
//                     break;
//                 }
//             }
//             s = s.substring(0,t);
//             t = 0;
//         }
//         return s;
//     }
// }
class Solution {
    public String longestCommonPrefix(String[] strs){
        String prefix =strs[0];
        for(int i=1;i<strs.length;i++){
            prefix=longestCommonPrefix(prefix,strs[i]);
            if(prefix==null) return "";
        }
        return prefix;
    }
    public String longestCommonPrefix(String str1,String str2) {
        int length=Math.min(str1.length(),str2.length());
        int index=0;
        for(int i=0;i<length;i++){
            if(str1.charAt(i)!=str2.charAt(i))
            break;
            else 
            index++;
        }
        return str1.substring(0,index);
    }
}

四、单词 

434. 字符串中的单词数 - 力扣（LeetCode）

 空格分开每一个单词，如果单词不为空，则count++。

class Solution {
    public int countSegments(String s) {
        int count = 0;  // 初始化计数器为0
        for (String word : s.split(" ")) {  // 将字符串按空格拆分为单词数组，并遍历数组
            if (!"".equals(word)) {  // 如果单词不为空串
                count++;  // 计数器加1
            }
        }
        return count;  // 返回单词数量
    }
}

 58. 最后一个单词的长度 - 力扣（LeetCode）

class Solution {
    public int lengthOfLastWord(String s) {
        s = s.trim();  // 去除字符串两端的空格
        String[] arr = s.split(" ");  // 将字符串按空格拆分为单词数组
        return arr[arr.length - 1].length();  // 返回数组中最后一个单词的长度
    }
}

五、字符串的反转

344. 反转字符串 - 力扣（LeetCode）

 双指针

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

先放在数组里 然后再做交换 

class Solution {
    public String reverseStr(String s, int k) {
        int n = s.length();
        char[] arr = s.toCharArray();
        for (int i = 0; i < n; i += 2 * k) {//起点是i，终点是i+k ，注意一下不要超了
            reverse(arr, i, Math.min(i + k, n) - 1);
        }
        return new String(arr);

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

}

557. 反转字符串中的单词 III - 力扣（LeetCode）

class Solution {
    public String reverseWords(String s) {
        char[] chars = s.toCharArray();  // 将字符串转换为字符数组
        int i = 0;
        for (int j = 0; j < chars.length; j++) {
            if (chars[j] == ' ') {  // 当遇到空格时，反转前面的单词
                reverse(chars, i, j - 1);  // 调用 reverse 方法反转字符数组中的指定范围
                i = j + 1;  // 更新下一个单词的起始位置
            }
        }
        reverse(chars, i, chars.length - 1);  // 反转最后一个单词（或整个字符串，如果没有空格）
        return String.valueOf(chars);  // 将反转后的字符数组转换为字符串并返回
    }

    private void reverse(char[] chars, int i, int j) {
        while (i < j) {  // 使用双指针将指定范围内的字符进行反转
            char temp = chars[i];
            chars[i++] = chars[j];
            chars[j--] = temp;
        }
    }
}

151. 反转字符串中的单词 - 力扣（LeetCode）

 

class Solution {
    public String reverseWords(String s) {
        char[] chars = s.toCharArray();  // 将字符串转换为字符数组
        char[] res = new char[chars.length + 1];  // 创建结果字符数组，长度比原数组多1，用于存放反转后的结果
        int i = chars.length - 1;  // 从字符串末尾开始遍历
        int star = 0;  // 结果字符数组的索引
        while (i >= 0) {
            while (i >= 0 && chars[i] == ' ') i--;  // 跳过末尾的空格
            int right = i;  // 记录当前单词的末尾索引
            while (i >= 0 && chars[i] != ' ') i--;  // 找到当前单词的起始索引
            for (int j = i + 1; j <= right; j++) {
                res[star++] = chars[j];  // 将当前单词的字符复制到结果字符数组中
                if (j == right) {
                    res[star++] = ' ';  // 在单词末尾添加一个空格
                }
            }
        }
        return new String(res, 0, star - 1);  // 将结果字符数组转换为字符串并返回，去除最后一个多余的空格
    }
}

---

总结