《算法》——子字符串查找

定义

子字符串查找：给定一段长度为N的文本和一个长度为M的模式(pattern)字符串，在文本中找到一个和该模式相符的子字符串。

暴力子字符串查找算法

package algorithm.substring;

/**
 * 描述：几种子字符串查找
 * Created by zjw on 2021/9/5 15:29
 */
public class CommonSearchSubstring {

    /**
     * 暴力子字符串查找
     * @param pat
     * @param txt
     * @return
     */
    public static int search(String pat, String txt) {
        int M = pat.length();
        int N = txt.length();
        for (int i = 0; i <= N - M; i++) {
            int j;
            for (j = 0; j < M; j++) {
                if (txt.charAt(i + j) != pat.charAt(j)) {
                    break;
                }
            }
            if (j == M) return i;//找到匹配
        }
        return N;//未找到匹配
    }

    /**
     * 暴力子字符串查找优化
     * @param pat
     * @param txt
     * @return
     */
    public static int search2(String pat, String txt) {
        int j,M = pat.length();
        int i,N = txt.length();
        for (i = 0, j = 0; i < N && j < M; i++) {
            if (txt.charAt(i) == pat.charAt(j)) j++;
            else {
                i -= j;
                j=0;
            }
        }
        if (j==M) return i - M;//找到匹配
        else return N;//未找到匹配

    }

}

Knuth-Morris-Pratt字符串查找算法

package algorithm.substring;


/**
 * 描述：Knuth-Morris-Pratt字符串查找算法
 * Created by zjw on 2021/9/5 15:39
 */
public class KMP {
    private final int R;       // 基数
    private final int m;       // 匹配字符长度
    private int[][] dfa;       // the KMP automoton

    public KMP(String pat) {
        this.R = 256;
        this.m = pat.length();

        // build DFA from pattern
        dfa = new int[R][m]; 
        dfa[pat.charAt(0)][0] = 1; 
        for (int x = 0, j = 1; j < m; j++) {
            for (int c = 0; c < R; c++) 
                dfa[c][j] = dfa[c][x];     //  mismatch cases. 
            dfa[pat.charAt(j)][j] = j+1;   // Set match case. 
            x = dfa[pat.charAt(j)][x];     // Update restart state. 
        } 
    }

    /**
     * 
     * @param pattern
     * @param R
     */
    public KMP(char[] pattern, int R) {
        this.R = R;
        this.m = pattern.length;

        // build DFA from pattern
        int m = pattern.length;
        dfa = new int[R][m]; 
        dfa[pattern[0]][0] = 1; 
        for (int x = 0, j = 1; j < m; j++) {
            for (int c = 0; c < R; c++) 
                dfa[c][j] = dfa[c][x];     //  mismatch cases. 
            dfa[pattern[j]][j] = j+1;      // Set match case. 
            x = dfa[pattern[j]][x];        // Update restart state. 
        } 
    }

    /**
     * 
     * @param txt
     * @return
     */
    public int search(String txt) {

        // simulate operation of DFA on text
        int n = txt.length();
        int i, j;
        for (i = 0, j = 0; i < n && j < m; i++) {
            j = dfa[txt.charAt(i)][j];
        }
        if (j == m) return i - m;    // found
        return n;                    // not found
    }

    /**
     * 
     * @param text
     * @return
     */
    public int search(char[] text) {

        // simulate operation of DFA on text
        int n = text.length;
        int i, j;
        for (i = 0, j = 0; i < n && j < m; i++) {
            j = dfa[text[i]][j];
        }
        if (j == m) return i - m;    // found
        return n;                    // not found
    }
}

Boyer-Moore字符串匹配算法

package algorithm.substring;

/**
 * 描述：启发式地处理不匹配的字符
 * Created by zjw on 2021/9/5 15:43
 */
public class BoyerMoore {
    private final int R;     // 基数
    private int[] right;     // 跳过不匹配字符数组

    private char[] pattern;  // 将匹配存储为数组
    private String pat;      

    public BoyerMoore(String pat) {
        this.R = 256;
        this.pat = pat;
        // 匹配字符最右边出现的位置
        right = new int[R];
        for (int c = 0; c < R; c++)
            right[c] = -1;
        for (int j = 0; j < pat.length(); j++)
            right[pat.charAt(j)] = j;
    }

    public BoyerMoore(char[] pattern, int R) {
        this.R = R;
        this.pattern = new char[pattern.length];
        for (int j = 0; j < pattern.length; j++)
            this.pattern[j] = pattern[j];

        // 匹配字符最右边出现的位置
        right = new int[R];
        for (int c = 0; c < R; c++)
            right[c] = -1;
        for (int j = 0; j < pattern.length; j++)
            right[pattern[j]] = j;
    }


    public int search(String txt) {
        int m = pat.length();
        int n = txt.length();
        int skip;
        for (int i = 0; i <= n - m; i += skip) {
            skip = 0;
            for (int j = m-1; j >= 0; j--) {
                if (pat.charAt(j) != txt.charAt(i+j)) {
                    skip = Math.max(1, j - right[txt.charAt(i+j)]);
                    break;
                }
            }
            if (skip == 0) return i;    // found
        }
        return n;                       // not found
    }



    public int search(char[] text) {
        int m = pattern.length;
        int n = text.length;
        int skip;
        for (int i = 0; i <= n - m; i += skip) {
            skip = 0;
            for (int j = m-1; j >= 0; j--) {
                if (pattern[j] != text[i+j]) {
                    skip = Math.max(1, j - right[text[i+j]]);
                    break;
                }
            }
            if (skip == 0) return i;    // found
        }
        return n;                       // not found
    }
}

Rabin-Karp指纹字符串查找算法

package algorithm.substring;

import java.math.BigInteger;
import java.util.Random;

/**
 * 描述：指纹字符串查找算法
 * Created by zjw on 2021/9/5 15:46
 */
public class RabinKarp {
    private String pat;      
    private long patHash;    // 匹配hash
    private int m;           // 匹配字符长度
    private long q;          // 一个大的素数，小到足以避免长时间溢出
    private int R;           // 基数
    private long RM;         // R^(M-1) % Q

    public RabinKarp(char[] pattern, int R) {
        this.pat = String.valueOf(pattern);
        this.R = R;        
        throw new UnsupportedOperationException("Operation not supported yet");
    }

    public RabinKarp(String pat) {
        this.pat = pat;      
        R = 256;
        m = pat.length();
        q = longRandomPrime();

        // //预计算机^（m-1）%q用于删除前导数字
        RM = 1;
        for (int i = 1; i <= m-1; i++)
            RM = (R * RM) % q;
        patHash = hash(pat, m);
    } 

    // 计算键[0..m-1]的hash值 
    private long hash(String key, int m) { 
        long h = 0; 
        for (int j = 0; j < m; j++) 
            h = (R * h + key.charAt(j)) % q;
        return h;
    }

    // pat[]是否匹配txt[i..i-m+1]？
    private boolean check(String txt, int i) {
        for (int j = 0; j < m; j++) 
            if (pat.charAt(j) != txt.charAt(i + j)) 
                return false; 
        return true;
    }

    public int search(String txt) {
        int n = txt.length(); 
        if (n < m) return n;
        long txtHash = hash(txt, m); 

        // //检查偏移量0处是否匹配
        if ((patHash == txtHash) && check(txt, 0))
            return 0;

        // //检查哈希匹配；如果哈希匹配，请检查是否完全匹配
        for (int i = m; i < n; i++) {
            //删除前导数字，添加尾随数字，检查是否匹配。 
            txtHash = (txtHash + q - RM*txt.charAt(i-m) % q) % q; 
            txtHash = (txtHash*R + txt.charAt(i)) % q; 

            // 匹配
            int offset = i - m + 1;
            if ((patHash == txtHash) && check(txt, offset))
                return offset;
        }

        // n不匹配
        return n;
    }


    // //随机31位数
    private static long longRandomPrime() {
        BigInteger prime = BigInteger.probablePrime(31, new Random());
        return prime.longValue();
    }
}