整理一下字符串的题，大部分是刷过的

java
class Solution {
    public int lengthOfLongestSubstring(String s) {
        // 使用一个 HashSet 来存储当前窗口中的字符
        Set<Character> window = new HashSet<>();
        
        int left = 0, right = 0;
        int maxLength = 0;
        
        while (right < s.length()) {
            // 如果当前字符不在窗口中，则将其添加到窗口中
            if (!window.contains(s.charAt(right))) {
                window.add(s.charAt(right));
                // 更新最大长度
                maxLength = Math.max(maxLength, window.size());
                right++;
            } 
            // 如果当前字符在窗口中，则需要从左侧缩小窗口
            else {
                window.remove(s.charAt(left));
                left++;
            }
        }
        
        return maxLength;
    }
}

java
class Solution {
    public boolean isPalindrome(String s) {
         // 预处理字符串
        StringBuilder sb = new StringBuilder();
        for (char c : s.toCharArray()) {
            if (Character.isLetterOrDigit(c)) {
                sb.append(Character.toLowerCase(c));
            }
        }
        s = sb.toString();

        // 使用左右指针比较字符
        int left = 0, right = s.length() - 1;
        while (left < right) {
            if (s.charAt(left) != s.charAt(right)) {
                return false;
            }
            left++;
            right--;
        }

        return true;
    }
}

java
class Solution {
    public String reverseVowels(String s) {
        char[] chars = s.toCharArray();
        int left = 0, right = chars.length - 1;
        
        while (left < right) {
            // 从左边找到第一个元音字母
            while (left < right && !isVowel(chars[left])) {
                left++;
            }
            
            // 从右边找到第一个元音字母
            while (left < right && !isVowel(chars[right])) {
                right--;
            }
            
            // 交换左右两个元音字母
            if (left < right) {
                char temp = chars[left];
                chars[left] = chars[right];
                chars[right] = temp;
                left++;
                right--;
            }
        }
        
        return new String(chars);
    }
    
    private boolean isVowel(char c) {
        return "aeiouAEIOU".indexOf(c) != -1;
    }
}

java
class Solution {
    public int compress(char[] chars) {
         int write = 0, read = 0;
        int n = chars.length;
        
        while (read < n) {
            char currentChar = chars[read];
            int count = 1;
            
            // 统计当前字符的连续个数
            while (read + 1 < n && chars[read + 1] == currentChar) {
                count++;
                read++;
            }
            
            // 将当前字符写入结果数组
            chars[write++] = currentChar;
            
            // 如果个数大于1, 将个数写入结果数组
            if (count > 1) {
                String countStr = String.valueOf(count);
                for (char c : countStr.toCharArray()) {
                    chars[write++] = c;
                }
            }
            
            read++;
        }
        
        return write;
    }
}

java
class Solution {
    public int findLUSlength(String[] strs) {
        // 先对字符串数组排序,长度较长的序列更可能是特殊序列
        Arrays.sort(strs, (a, b) -> b.length() - a.length());

        for (int i = 0; i < strs.length; i++) {
            boolean isSpecial = true;
            for (int j = 0; j < strs.length; j++) {
                // 如果存在其他字符串是当前字符串的子序列,则当前字符串不是特殊序列
                if (i != j && isSubsequence(strs[i], strs[j])) {
                    isSpecial = false;
                    break;
                }
            }
            if (isSpecial) {
                // 找到了特殊序列,返回它的长度
                return strs[i].length();
            }
        }

        // 没有找到特殊序列,返回-1
        return -1;
    }

    private boolean isSubsequence(String s1, String s2) {
        int i = 0, j = 0;
        while (i < s1.length() && j < s2.length()) {
            if (s1.charAt(i) == s2.charAt(j)) {
                i++;
            }
            j++;
        }
        return i == s1.length();
    }
}

java
class Solution {
    public int[] shortestToChar(String s, char c) {
        int n = s.length();
        int[] answer = new int[n];

        // 从左到右遍历
        int prevIndex = -n;
        for (int i = 0; i < n; i++) {
            if (s.charAt(i) == c) {
                prevIndex = i;
            }
            answer[i] = i - prevIndex;
        }

        // 从右到左遍历
        prevIndex = 2 * n;
        for (int i = n - 1; i >= 0; i--) {
            if (s.charAt(i) == c) {
                prevIndex = i;
            }
            answer[i] = Math.min(answer[i], prevIndex - i);
        }

        return answer;
    }
}