实现 Java 的 indexOf 方法（子字符串搜索）

Question

我只是第二学期的 CS 学生，不能使用任何众所周知的高效子字符串搜索算法。我需要使用以下方法签名来实现 indexOf 方法：

int indexOf(String str, String pattern) 返回模式作为 str 的子字符串出现的第一个位置的索引。

这是我尝试的：

首先，我创建了一个重载方法索引，其签名为 indexOf(String str, char ch, int startIndex)，它返回 char 的第一个位置的索引，否则返回 -1。

 private int indexOf(String str, char ch, int startIndex) {
    for(int i = startIndex; i < str.length(); i++)
        if(str.charAt(i) == ch) return i;

    return -1;
}

现在我编写搜索子字符串 (pattern) 的方法。

private int indexOf(String str, String pattern) {
    int headIndex = indexOf(str, pattern.charAt(0), 0);
    int tailIndex = indexOf(str, pattern.charAt(pattern.length() - 1), 0);

    if(headIndex == -1 || tailIndex == -1) return -1; // no substring match

    while(true) {
        int j = 0;
        for(int i = headIndex; i <= tailIndex; i++)
            if(str.charAt(headIndex) != pattern.charAt(j++)) { //if substring does not match then compute a new head and tail Index
                headIndex = indexOf(str, pattern.charAt(0), headIndex);
                tailIndex = indexOf(str, pattern.charAt(pattern.length() - 1), tailIndex);
                j = 0;
                i = headIndex + 1;
                if(headIndex == -1 || tailIndex == -1) return -1;
                break;
            }

        if(headIndex >= 0) return headIndex;
    }
}

我相信我已经接近了，但像 indexOf("Hellolo", "lo") 这样的调用返回 2 而不是 3。我正试图找出我的逻辑哪里出了问题并需要帮助。

我不允许使用任何特殊的字符串方法，除了长度。

Answer 1

在您的代码中，您正在寻找单个字符而不是字符串的第一个索引。

int headIndex = indexOf(str, pattern.charAt(0), 0);

如果我们假设str = Hellolo" 和pattern = "lo"，那么上面的代码正在寻找l 而不是lo。

编辑：如果要查找字符串"lo" 的第一次出现，则必须将代码更改为

int headIndex = indexOf(str, pattern, 0);

Answer 2

indexOf("Hellolo", "lo") 返回 2，因为计数是从零开始的... 这里是doc

public int indexOf(int ch)

返回此字符串中第一次出现的索引 指定的字符。如果一个值为 ch 的字符出现在 此 String 对象表示的字符序列，然后是索引 （在 Unicode 代码单元中）第一次出现的此类事件被返回。为了 ch的值在0到0xFFFF（含）的范围内，

Answer 3

我只是以尽可能简单的方式编写代码。

package com.ggl.testing;

public class MyString {

    public static void main(String[] args) {
        MyString myString = new MyString();
        String string = "abcdefghij";
        String pattern = "defg";
        System.out.println(myString.indexOf(string, pattern));

        pattern = "ghij";
        System.out.println(myString.indexOf(string, pattern));

        pattern = "asdf";
        System.out.println(myString.indexOf(string, pattern));
    }

    public int indexOf(String string, String pattern) {
        int length = string.length() - pattern.length();
        for (int index = 0; index <= length; index++) {
            if (patternMatch(string, index, pattern)) {
                return index;
            }
        }

        return -1;
    }

    private boolean patternMatch(String string, int index, String pattern) {
        int i = index;
        for (int j = 0; j < pattern.length(); j++) {
            if (string.charAt(i) != pattern.charAt(j)) {
                return false;
            }
            i++;
        }

        return true;
    }

}

Answer 4

int headIndex = indexOf(str, pattern.charAt(0));
int tailIndex = indexOf(str, pattern.charAt(pattern.length() - 1));

if(headIndex == -1 || tailIndex == -1) return -1; // no substring match

Buggy -> 考虑这种情况：

String str = "nevern";
String pattern = "vern";

我认为专注于头部字符就足够了：

public class Search {


    static private int indexOf(String src, char ch, int startIndex) {
        for(int i = startIndex; i < src.length(); i++)
            if(src.charAt(i) == ch) return i;

        return -1;
    }

    static private int indexOf(String src, String pat) {
        int head_in_src = 0;

        while (-1 != (head_in_src = indexOf(src, pat.charAt(0), head_in_src))) {
            if (head_in_src + pat.length() > src.length() - head_in_src)
                return -1;
            boolean match = true;
            int offset = 0;
            for (; offset < pat.length(); offset++) {
                if (src.charAt(offset + head_in_src) != pat.charAt(offset)) {
                    match = false;
                    break;
                }
            }
            if (true == match)
                return head_in_src;
            head_in_src += offset;
        }
        return -1;
    }

    public static void main(String[] args) {
        String src = "ne-nevern-nevern";
        String pat = "ever";
        String pat1 = "ne";
        String pat2 = "vern";
        String pat3 = "everne";
        String pat4= "-ne-";
        String pat5= "ner";

        System.out.printf("src=%1$s, pat=%2$s, index=%3$d%n", src, pat, indexOf(src, pat));
        System.out.printf("src=%1$s, pat1=%2$s, index=%3$d%n", src, pat1, indexOf(src, pat1));
        System.out.printf("src=%1$s, pat2=%2$s, index=%3$d%n", src, pat2, indexOf(src, pat2));
        System.out.printf("src=%1$s, pat3=%2$s, index=%3$d%n", src, pat3, indexOf(src, pat3));
        System.out.printf("src=%1$s, pat4=%2$s, index=%3$d%n", src, pat4, indexOf(src, pat4));
        System.out.printf("src=%1$s, pat5=%2$s, index=%3$d%n", src, pat5, indexOf(src, pat5));
    }
}

输出：

src=ne-nevern-nevern, pat=ever, index=4
src=ne-nevern-nevern, pat1=ne, index=0
src=ne-nevern-nevern, pat2=vern, index=5
src=ne-nevern-nevern, pat3=everne, index=-1
src=ne-nevern-nevern, pat4=-ne-, index=-1
src=ne-nevern-nevern, pat5=ner, index=-1