18 道 Java 字符串相关算法题思路简介及代码实现

1. 模拟实现trim()方法

   • 创建一个函数，遍历字符串，记录第一个非空格字符的位置作为左边界，同时记录最后一个非空格字符的位置作为右边界，然后截取左右边界的子串。

2. 字符串反转

   • 整体反转：将字符串转换为字符数组，使用双指针交换首尾字符直至中间，然后重新构建字符串。
   • 指定部分反转：同样将子串转换为字符数组，使用双指针交换指定范围内的首尾字符。

3. 查找子串出现次数

   • 使用indexOf()方法，从头开始查找子串，每当找到一个就更新计数，并将下次查找的起始位置设为本次查找结束位置+1，直到找不到为止。

4. 判断字符串是否为回文

   • 可以通过比较字符串与其反转字符串是否相等来判断，或者利用双指针从两端向中间移动比较字符是否一致。

5. 连接字符串不使用+或concat()

   • 创建一个StringBuilder或StringBuffer对象，调用append()方法逐个添加字符串，最后调用toString()方法返回结果。

6. 替换子串

   • 使用StringBuilder的replace()方法，或者手动遍历字符串并在发现匹配子串时插入新子串。

7. 检查字符串是否包含连续重复字符

   • 遍历字符串，比较当前字符与下一个字符是否相等，若相等则表示存在连续重复字符。

8. 删除字符串中连续的重复字符

   • 创建一个新的StringBuilder，遍历输入字符串，在连续字符重复时只将首个字符添加至新字符串中。

9. 翻转单词顺序

   • 分割字符串为单词数组，然后逆序遍历数组并将单词之间加入空格，最后合并成新的字符串。

10. 字符串中最长的公共前后缀

    • 从前向后遍历字符串，同时从后向前遍历字符串，对比两者的字符，找到最长的公共前缀和后缀。

11. KMP算法实现

    • 构建next数组，用于存储模式串的部分匹配值，然后在文本串中搜索，失败时利用next数组快速回溯。

12. Z字形变换

    • 创建一个二维数组模拟Z字形路径，根据行数和列数的奇偶性决定字符的填充方向。

13. 判断两个字符串是否互为变形词（异位词）

    • 将两个字符串转换为字符数组并排序，比较排序后的数组是否相等。

14. 计算字符串的最长递增子序列

    • 使用动态规划思想，dp[i]表示以第i个字符结尾的最长递增子序列长度，遍历字符串更新dp数组。

15. 字符串分割问题

    • 使用Java的split()方法传入分隔符，或者手动遍历字符串并根据分隔符切割成子串放入数组。

16. 最小窗口子串

    • 使用滑动窗口方法，维持一个满足条件的窗口，不断尝试收缩和扩展窗口，记录满足条件的最小区间。

17. 验证括号的有效性

    • 使用栈数据结构，遍历字符串，遇到左括号入栈，遇到右括号检查栈顶元素是否与之匹配，匹配则出栈，遍历结束后栈为空则有效。

18. 字符替换求解最小子串

    • 计算字符映射后的字符串与目标字符串的编辑距离（Levenshtein距离），编辑距离即为最少替换次数。

1. 模拟实现trim()方法

public String customTrim(String str) {
    int start = 0, end = str.length() - 1;
    while (start < str.length() && str.charAt(start) == ' ') start++;
    while (end >= 0 && str.charAt(end) == ' ') end--;
    return str.substring(start, end + 1);
}

2. 字符串反转

public String reverseWholeString(String s) {
    char[] chars = s.toCharArray();
    int start = 0, end = chars.length - 1;
    while (start < end) {
        char temp = chars[start];
        chars[start] = chars[end];
        chars[end] = temp;
        start++;
        end--;
    }
    return new String(chars);
}

// 反转指定部分字符串
public String reverseSubstring(String s, int i, int j) {
    char[] chars = s.toCharArray();
    while (i < j) {
        char temp = chars[i];
        chars[i] = chars[j];
        chars[j] = temp;
        i++;
        j--;
    }
    return new String(chars);
}

3. 查找子串出现次数

public int countSubStr(String str, String subStr) {
    int count = 0;
    int index = 0;
    while ((index = str.indexOf(subStr, index)) != -1) {
        count++;
        index += subStr.length();
    }
    return count;
}

4. 判断字符串是否为回文：

public boolean isPalindrome(String str) {
    // 移除非字母数字字符并转换为小写
    str = str.replaceAll("[^a-zA-Z0-9]", "").toLowerCase();
    
    int start = 0, end = str.length() - 1;
    while (start < end) {
        if (str.charAt(start) != str.charAt(end)) {
            return false;
        }
        start++;
        end--;
    }
    return true;
}

或 最简单实现：

public boolean isPalindrome(String str) {  
    return new StringBuffer(str).reverse().toString().equals(str);
}

5. 连接字符串不使用 + 或 concat()：

import java.util.Arrays;

public String concatenateStrings(String... strings) {
    StringBuilder sb = new StringBuilder();
    for (String str : strings) {
        sb.append(str);
    }
    return sb.toString();
}

// 使用方式
String result = concatenateStrings("Hello", " ", "World");

或者

import java.util.ArrayList;
import java.util.List;

public String concatenateStrings(List<String> stringList) {
    StringBuilder sb = new StringBuilder();
    for (String str : stringList) {
        sb.append(str);
    }
    return sb.toString();
}

// 使用方式
List<String> list = Arrays.asList("Hello", " ", "World");
String result = concatenateStrings(list);

6. 替换子串：

public String replaceSubstring(String original, String oldSubstring, String newSubstring) {
    return original.replace(oldSubstring, newSubstring);
}

// 使用方式
String input = "Hello, World!";
String replaced = replaceSubstring(input, "World", "Dolly");
System.out.println(replaced); // 输出: Hello, Dolly!

注意：第三个问题的实现直接使用了Java自带的replace()方法，如果你想要自己实现这个功能，可以创建一个循环遍历原字符串，检测每个子串，并在发现匹配项时替换它，然后拼接新字符串。不过这种方式相比内置方法效率较低，除非有特殊需求，否则推荐直接使用replace()方法。

7. 检查字符串是否包含连续重复字符

public boolean hasConsecutiveRepeatingChars(String str) {
    for (int i = 0; i < str.length() - 1; i++) {
        if (str.charAt(i) == str.charAt(i + 1)) {
            return true;
        }
    }
    return false;
}

8. 删除字符串中连续重复的字符，只保留一个

public String removeConsecutiveDuplicates(String str) {
    StringBuilder sb = new StringBuilder();
    for (int i = 0; i < str.length(); ) {
        char currentChar = str.charAt(i);
        sb.append(currentChar);
        while (i + 1 < str.length() && str.charAt(i) == str.charAt(i + 1)) {
            i++; // skip the duplicate character
        }
        i++;
    }
    return sb.toString();
}

9. 翻转单词顺序

public String reverseWordsInString(String str) {
    String[] words = str.split("\\s+");
    StringBuilder reversed = new StringBuilder();
    for (int i = words.length - 1; i >= 0; i--) {
        reversed.append(words[i]);
        if (i > 0) {
            reversed.append(' '); // Add space between words in reversed order
        }
    }
    return reversed.toString().trim(); // Trim to remove leading or trailing spaces
}

// 如果字符串本身没有多余空格，可以简化为
public String reverseWordsNoExtraSpaces(String str) {
    String[] words = str.split(" ");
    StringBuilder reversed = new StringBuilder();
    for (int i = words.length - 1; i >= 0; i--) {
        reversed.append(words[i]);
        if (i > 0) {
            reversed.append(' ');
        }
    }
    return reversed.toString();
}

10. 找出字符串中最长的公共前后缀

public String longestCommonPrefixSuffix(String str) {
    if (str.isEmpty()) {
        return "";
    }

    int n = str.length();
    String reversedStr = new StringBuilder(str).reverse().toString();

    for (int i = 0; i < n; i++) {
        if (str.charAt(i) != reversedStr.charAt(i)) {
            break;
        }
    }

    return str.substring(0, i);
}

这段代码首先检查字符串是否为空，然后创建一个反转后的字符串，通过比较原始字符串和其反转串对应位置上的字符是否相等来确定最长公共前后缀。最后返回该公共前后缀子串。

11. KMP算法实现字符串模式匹配

public class KMP {
    public static int kmpSearch(String text, String pattern) {
        if (text == null || pattern == null) return -1;
        
        int[] lps = computeLPS(pattern);
        int i = 0, j = 0;
        while (i < text.length()) {
            if (text.charAt(i) == pattern.charAt(j)) {
                i++;
                j++;
            }
            if (j == pattern.length()) {
                return i - j;
            } else if (i < text.length() && text.charAt(i) != pattern.charAt(j)) {
                if (j != 0) {
                    j = lps[j - 1];
                } else {
                    i++;
                }
            }
        }
        return -1; // Not found
    }

    private static int[] computeLPS(String pattern) {
        int[] lps = new int[pattern.length()];
        int len = 0;
        for (int i = 1; i < pattern.length(); i++) {
            while (len > 0 && pattern.charAt(len) != pattern.charAt(i)) {
                len = lps[len - 1];
            }
            if (pattern.charAt(len) == pattern.charAt(i)) {
                len++;
            }
            lps[i] = len;
        }
        return lps;
    }
}

12. Z字形变换

public class ZigZagConversion {
    public static String convert(String s, int numRows) {
        if (numRows == 1 || s.length() <= numRows) return s;
        StringBuilder[] rows = new StringBuilder[numRows];
        for (int i = 0; i < numRows; i++) {
            rows[i] = new StringBuilder();
        }
        int t = 0, direction = -1;
        for (char c : s.toCharArray()) {
            rows[t].append(c);
            t += direction;
            if (t == 0 || t == numRows - 1) {
                direction = -direction;
            }
        }
        StringBuilder result = new StringBuilder();
        for (StringBuilder row : rows) {
            result.append(row);
        }
        return result.toString();
    }
}

13. 判断两个字符串是否互为变形词（异位词）

import java.util.Arrays;

public class AnagramChecker {
    public static boolean areAnagrams(String s, String t) {
        if (s.length() != t.length()) return false;
        char[] sChars = s.toCharArray(), tChars = t.toCharArray();
        Arrays.sort(sChars);
        Arrays.sort(tChars);
        return Arrays.equals(sChars, tChars);
    }
}

14. 计算字符串的最长递增子序列

public class LongestIncreasingSubsequence {
    public static int findLongestIncreasingSubsequenceLength(String s) {
        int[] dp = new int[s.length()];
        for (int i = 0; i < s.length(); i++) {
            dp[i] = 1;
            for (int j = 0; j < i; j++) {
                if (s.charAt(i) > s.charAt(j)) {
                    dp[i] = Math.max(dp[i], dp[j] + 1);
                }
            }
        }
        int maxLength = 0;
        for (int length : dp) {
            maxLength = Math.max(maxLength, length);
        }
        return maxLength;
    }
}

15. 字符串分割问题

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

public class StringSplitter {
    public static List<String> splitStringByDelimiter(String s, String delimiter) {
        return Arrays.stream(s.split(delimiter))
                .map(String::trim) // Optionally trim each token
                .collect(Collectors.toList());
    }
}

16. 最小窗口子串（滑动窗口法）

import java.util.HashMap;
import java.util.Map;

public class MinWindowSubstring {
    public String minWindow(String s, String t) {
        Map<Character, Integer> targetMap = new HashMap<>();
        for (char c : t.toCharArray()) {
            targetMap.put(c, targetMap.getOrDefault(c, 0) + 1);
        }

        int left = 0, right = 0;
        int required = targetMap.size();
        int formed = 0;
        int minLength = Integer.MAX_VALUE;
        String minWindow = "";

        Map<Character, Integer> windowMap = new HashMap<>();

        while (right < s.length()) {
            char rightChar = s.charAt(right);
            windowMap.put(rightChar, windowMap.getOrDefault(rightChar, 0) + 1);

            if (targetMap.containsKey(rightChar) && windowMap.get(rightChar) == targetMap.get(rightChar)) {
                formed++;
            }

            while (left <= right && formed == required) {
                char leftChar = s.charAt(left);
                
                if (minLength > right - left + 1) {
                    minLength = right - left + 1;
                    minWindow = s.substring(left, right + 1);
                }

                windowMap.put(leftChar, windowMap.get(leftChar) - 1);
                if (windowMap.get(leftChar) < targetMap.get(leftChar)) {
                    formed--;
                }
                left++;
            }
            right++;
        }

        return minWindow;
    }
}

17. 验证括号的有效性

public class BracketValidation {
    public boolean isValid(String s) {
        Stack<Character> stack = new Stack<>();
        for (char c : s.toCharArray()) {
            if (c == '(' || c == '[' || c == '{') {
                stack.push(c);
            } else if (c == ')' && !stack.isEmpty() && stack.peek() == '(') {
                stack.pop();
            } else if (c == ']' && !stack.isEmpty() && stack.peek() == '[') {
                stack.pop();
            } else if (c == '}' && !stack.isEmpty() && stack.peek() == '{') {
                stack.pop();
            } else {
                return false;
            }
        }
        return stack.isEmpty();
    }
}

18. 字符替换求解最小子串

import java.util.HashMap;
import java.util.Map;

public class CharReplacement {
    public String minReplaceToMakeGood(String s, Map<Character, Character> mapping) {
        StringBuilder sb = new StringBuilder();
        for (char c : s.toCharArray()) {
            if (!mapping.containsKey(c)) {
                sb.append(c);
            } else {
                sb.append(mapping.get(c));
            }
        }
        
        // 此处假设目标是将所有字符变为'好'
        String desired = "好好";
        int minDistance = s.length();
        for (int i = 0; i < sb.length(); i++) {
            for (int j = i + 1; j <= sb.length(); j++) {
                String substring = sb.substring(i, j);
                if (substring.equals(desired)) {
                    minDistance = Math.min(minDistance, j - i);
                }
            }
        }
        
        // 返回替换后子串长度，因为具体的子串可以通过原字符串和起始结束位置计算得出
        return minDistance == s.length() ? "-1" : String.valueOf(minDistance);
    }
}