Java LeetCode 28 strStr 找出字符串中第一个匹配项的下标 三种解法：RK，BM，KMP

java 代码：RK解法

/*
 * 字符串匹配算法：RK算法
 */
public class Demo001 {

    public static void main(String[] args) {
        String str = "aacdesadsdfer";
        String pattern = "adsd";
        int index = rabinKarp(str, pattern);
        System.out.println("首次出现的位置：" + index);  // 6
    }

    private static int rabinKarp(String str, String pattern) {
        // TODO Auto-generated method stub

        int m = str.length();                       //主串长度
        int n = pattern.length();                   //模式串的长度
        if (n > m){
            return -1;
        }
        int patternCode = hash(pattern);            //计算模式串的hash值
        int strCode = hash(str.substring(0, n));    //计算主串当中第一个和模式串等长的子串hash值
        for (int i = 0; i < m - n + 1; i++) {
            if (strCode == patternCode && compareString(i, str, pattern)) { //用模式串的hash值和主串的局部hash值比较, 如果匹配，则进行精确比较；如果不匹配，计算主串中相邻子串的hash值。
                return i;
            }
            if (i < m - n) { //如果不是最后一轮，更新主串从i到i+n的hash值
                strCode = nextHash(str, strCode, i, n);
            }
        }
        return -1;
    }

    private static int hash(String str) {
        // TODO Auto-generated method stub
        int hashcode = 0;
        for (int i = 0; i < str.length(); i++) { //这里采用最简单的hashconde计算方式： 把a当做1，把b当做2，把c当做3......然后按位相加
            hashcode += str.charAt(i) - 'a';
        }
        return hashcode;
    }

    private static int nextHash(String str, int hash, int index, int n) {
        // TODO Auto-generated method stub
        hash -= str.charAt(index) - 'a';
        hash += str.charAt(index + n) - 'a';
        return hash;
    }

    private static boolean compareString(int i, String str, String pattern) {
        // TODO Auto-generated method stub
        String strSub = str.substring(i, i + pattern.length());
        return strSub.equals(pattern);
    }
}

java代码：BM解法

/*
 * 字符串匹配算法：BM算法
 */
public class Demo002 {

    public static void main(String[] args) {
        String str = "GTTATAGCTGGTAGCGGCGAA";
        String pattern = "GTAGCGGCG";
        int index = boyerMoore(str, pattern);
        System.out.println("首次出现的位置：" + index); // 10
    }

    private static int boyerMoore(String str, String pattern) {
        // TODO Auto-generated method stub
        int strLength = str.length();
        int patternLength = pattern.length();
        int start = 0; //模式串的起始位置
        int i;
        while (start <= strLength - patternLength) {
            for (i = patternLength - 1; i >= 0; i--) {          // 从后向前，逐个字符比较
                if (str.charAt(start + i) != pattern.charAt(i)) //发现坏字符，跳出比较， i记录了坏字符的位置
                    break;
            }
            if (i == -1) { //匹配成功， 返回第一次匹配的下标
                return start;
            }
            int charIndex = findCharacter(pattern, str.charAt(start + i), i); // 寻找坏字符在模式串中的对应位置
            int bcOffset = charIndex >= 0 ? i - charIndex : i + 1;            // 计算坏字符产生的位移
            start += bcOffset;
        }
        return -1;
    }

    private static int findCharacter(String pattern, char badCharacter, int index) {
        // TODO Auto-generated method stub
        for (int i = index - 1; i >= 0; i--) {
            if (pattern.charAt(i) == badCharacter) {
                return i;
            }
        }
        return -1;
    }
}

java代码：KMP解法

/*
 * 字符串匹配算法：KMP算法
 */
public class Demo003 {
	public static void main(String[] args) {
		String str = "GTGTGTCCCCTGGGCTaGTGGTGTGTGCFAA";
		String pattern = "GTGTGTG";
		int index = kmp(str, pattern);
		System.out.println("首次出现位置： " + index); // 20
	}

	private static int kmp(String str, String pattern) {
		// TODO Auto-generated method stub
		int[] next = getNexts(pattern);
		int j = 0;
		for(int i = 0; i < str.length(); i++) { //主循环，遍历主串字符
			while(j > 0 && str.charAt(i) != pattern.charAt(j)) { // 遇到坏字符时，查询next数组并改变模式串的起点
				j = next[j];
			}
			if (str.charAt(i)== pattern.charAt(j)) {
				j++;
			}
			if (j==pattern.length()) { // 匹配成功， 返回下标
				return i - pattern.length() + 1;
			}
		}
		return -1;
	}

	private static int[] getNexts(String pattern) { // 通过模式串， 生产 next 数组
		// TODO Auto-generated method stub
		int[] next = new int[pattern.length()];
		int j = 0;
		for(int i = 2; i < pattern.length(); i++){
			while(j != 0 && pattern.charAt(j) != pattern.charAt(i-1)) {
				j = next[j]; // 从next[i+1]的求解回溯到 next[j]
			}
			if (pattern.charAt(j) == pattern.charAt(i-1)) {
				j++;
			}
			next[i] = j;
		}
		return next;
	}
}