Question

  public class StringIsSubstring {


public static void main(String[] args) {
    String s1= new String("anurag");
    String s2=new String("anu");

    char a[]=s1.toCharArray();
    char b[]=s2.toCharArray();
    int i=0;
    int j=0;

    while(i<a.length && j<b.length)
    {
        if(a[i]==b[j])
        {
            i++;
            j++;
        }
        else
        {
            i++;
            j=0;
        }
        if(j == b.length)
        {
            System.out.println("we have found the substring");
        }
    }
}
 }

我编写了以下代码，发现一个String是其他的子串或不是。我不想使用任何库函数。有没有更有效的方法来做同样的

Answer 1

如果不使用库函数，则无法对String执行任何操作。例如，您的代码使用String.toCharArray。如果你可以使用它，那么你也可以使用String.indexOf并避免重新发明轮子。

人们建议Boyer-Moore。如果要搜索大量文本（在String个实例中或在某些其他表示中），这是一个不错的选择。但是，如果您只搜索一小块文本（如问题中所示），那么Boyer-Moore的设置成本意味着String.indexOf()将更快。这同样适用于其他复杂的算法。

所以，这个问题唯一有意义的方法就是这是一个家庭作业练习，其中包括对你可以用来解决问题的限制。在这种情况下，除非您正在进行算法课程，否则我怀疑他们希望您研究并实施复杂的算法。

Answer 2

您可以看到Boyer-Moore算法http://en.wikipedia.org/wiki/Boyer–Moore_string_search_algorithm和http://en.wikipedia.org/wiki/String_searching_algorithm。您还可以看到String.indexOf java实现。

Answer 3

Boyer-Moore已被建议，但我还要指出你的算法实际上已被打破。例如，如果你想测试“coa”是否是“cocoa”的子字符串（这是真的），那么你将匹配“co”，然后它会在下一个“c”上重置j，但是问题现在你已经“消耗”了启动子字符串的“c”，而你没有得到匹配。

Answer 4

之前的评论提供了应用库函数的充分理由，但是您可能需要应用替代算法。从你的帖子的声音，你可能会使用小s1s和s2s。为此，KnuthMorrisPratt算法可以提高效率。您可以这样实现：

public class SOStringDemo {

    public static void main(String[] args) {

        SOStringIsSubstring pair = new SOStringIsSubstring();

        pair.text = "thequickbrownfoxanujumpedoverthelazydogs";
        pair.pattern = "anu";

        pair.KMPMatch();

        return;
    }
}

和班级档案：

public class SOStringIsSubstring {

    public String text;
    public String pattern;
    private char[] textArray;
    private char[] patternArray;
    private int[] prefix;

    public void KMPMatch() {

        textArray = text.toCharArray();
        patternArray = pattern.toCharArray();
        int n = textArray.length;
        int m = patternArray.length;

        ComputePrefixFunction();
        int q = 0;

        for(int i = 0; i < n; i++) {
            while((q > 0) && (patternArray[q]) != textArray[i])
                q = prefix[q];
            if(patternArray[q] == textArray[i])
                ++q;
            if(q == m) {
                System.out.println("SubString is at index " + (i - m + 2));
                q = prefix[q-1];
            }
        }

        return;
    }

    public void ComputePrefixFunction() {

        int m = patternArray.length;
        prefix = new int [m];
        int k = 0;
        for(int q = 1; q < m; q++) {
            while((k > 0) && (patternArray[k] != patternArray[q]))
                k = prefix[k-1];
            if(patternArray[k] == patternArray[q])
                ++k;
            prefix[q] = k;
        }

        return;
    }
}

发现一个字符串是其他字符串的子字符串

4 个答案: