原始碼的github地址,可以下載到本地執行

串的匹配演算法

遍歷演算法

package demo;

/**
 * 串的模式匹配演算法
 */
public class StringIndex {

    /**
     * 求子串的定位函式，返回從pos位置起的第一個子串的位置
     * 返回子串T在主串S中第pos個字元之後第位置，若不存在 則函式值為0
     *
     * @return
     */
    public static int index(String S, String T, int pos) {

        //思路： 從S的第pos個字元開始 和T從第一個字元開始的每個字元進行匹配，如果全部匹配成功，則說明找到了子串
        //否則，就從S的下一個字元開始 繼續和T從第一個字元開始進行匹配 直到S的所有的字元都匹配完畢
        //雙迴圈 時間複雜度是n*n  最壞情況下 每次匹配到最後一個字元時候不等，這樣遍歷了兩層迴圈  ，最優情況下是n+m
        char[] s = S.toCharArray();
        char[] t = T.toCharArray();
        for (int j = pos; j < S.length(); j++) {
            int tag = 0;
            for (int i = j; i - j < t.length; i++) {
                if (s[i] != t[i - j]) {
                    tag = 1;
                    break;
                }
            }
            if (tag == 0) {
                return j;
            }
        }

        return 0;
    }

    /**
     * 求子串的定位函式，返回從pos位置起的第一個子串的位置
     * 返回子串T在主串S中第pos個字元之後第位置，若不存在 則函式值為0
     *
     * @return
     */
    public static int indextwo(String S, String T, int pos) {
        //思路： 從S的第pos個字元開始 和T從第一個字元開始的每個字元進行匹配，如果全部匹配成功，則說明找到了子串
        //否則，就從S的下一個字元開始 繼續和T從第一個字元開始進行匹配 直到S的所有的字元都匹配完畢

        int i = pos;
        int j = 0;
        char[] s = S.toCharArray();
        char[] t = T.toCharArray();
        while (i < s.length && j < t.length) {
            if (s[i] == t[j]) {
                i++;
                j++;
            } else {
                //重置指標，從新匹配
                i = i - j + 1;
                j = 0;
            }
        }
        if (j == t.length) {
            return (i - j);
        } else {
            return 0;
        }
        //這個時間複雜度 最差仍然為n*n 等於每次快迴圈結束時候都要重置指標
    }


    public static void main(String[] args) {
        String s = "ab12cde";
        String t = "12";
        System.out.println(index(s, t, 2));
        System.out.println(indextwo(s,t,2));
    }
}

 

輸出為
2
2