Java 在另一个字符串中查找字符串的字谜的最佳算法

我在破解编程面试书时遇到了这个话题。挑战在于找到给定较小字符串s在较大字符串b中的排列。我可以提出以下算法，其时间复杂度为O（B x S），其中S和B分别是给定的较小字符串和较大字符串的长度：

import java.util.HashMap;
public class AnagramAlgorithm {
public static void main(String[] args) {
    String s = "cbabadcbbabbcbabaabccbabc";
    String b = "abbc";

    printAnagramsOfB(s, b);
}

public static void printAnagramsOfB(String text, String pattern) {
    if(isEmpty(text) || isEmpty(pattern)) {
        System.out.println("Invalid Strings");
        return;
    }
    int patternLength = pattern.length();
    for (int i = 0; i < text.length() - patternLength + 1; i++) {
        String substring = text.substring(i, i + patternLength);
        if (isAnagram(pattern, substring)) {
            System.out.println("Anagram Found : " + substring);
        }
    }
}

public static boolean isEmpty(CharSequence str) {
    return str == null || str.length() == 0;
}

public static boolean isAnagram(String pattern, String substring) {
    if (pattern.length() != substring.length()) {
        System.out.println("SubString length doesn't match the length of Given String");
        return false;
    }
    char[] subStringArr = substring.toCharArray();
    char[] patternArr = pattern.toCharArray();
    HashMap<Character, Integer> mapPattern = new HashMap<>();
    HashMap<Character, Integer> mapSubstring = new HashMap<>();
    for (int i = 0; i < subStringArr.length; i++) {
        if (mapSubstring.containsKey(subStringArr[i])) {
            int count = mapSubstring.get(subStringArr[i]);
            mapSubstring.put(subStringArr[i], count + 1);
        } else {
            mapSubstring.put(subStringArr[i], 1);
        }
        if (mapPattern.containsKey(patternArr[i])) {
            int count = mapPattern.get(patternArr[i]);
            mapPattern.put(patternArr[i], count + 1);
        } else {
            mapPattern.put(patternArr[i], 1);
        }
    }
    return mapPattern.equals(mapSubstring);
}
}

import java.util.HashMap；
公共类AnagramAlgorithm{
公共静态void main（字符串[]args）{
字符串s=“cbabadcbabcbabccbabc”；
字符串b=“abbc”；
平面图b（s，b）；
}
公共静态void printanagramsoff（字符串文本、字符串模式）{
if（isEmpty（文本）| | isEmpty（模式））{
System.out.println（“无效字符串”）；
返回；
}
int patternLength=pattern.length（）；
对于（int i=0；i

---

书中提到，最优化的算法是O（B）。我想不出这样的算法。根据我的想法，对于整体复杂度为O（B），用于确定子串是否为一个字谜的算法应该是O（1），即，没有任何循环。这可能吗？或者是否有其他方法来实现最佳算法？

此算法以线性时间运行。如果你正在准备面试，那么你可能会自己发现这里发生了什么；）

公共类求解器{
列表求解（字符串t、字符串s）{
HashMap charCountInT=新的HashMap（）；
对于（int i=0；i

此算法以线性时间运行。如果你正在准备面试，那么你可能会自己发现这里发生了什么；）

公共类求解器{
列表求解（字符串t、字符串s）{
HashMap charCountInT=新的HashMap（）；
对于（int i=0；i