字符串处理算法总结：KMP算法和Tier字典

最新推荐文章于 2022-07-10 20:05:22 发布

龙朦

最新推荐文章于 2022-07-10 20:05:22 发布

阅读量237

点赞数

分类专栏：算法文章标签： KMP Tier 字符串算法

本文链接：https://blog.csdn.net/qq_18670949/article/details/99713415

版权

算法专栏收录该内容

1 篇文章 0 订阅

订阅专栏

文章目录

KMP算法
Trie字典
参考文献：

KMP算法

使用场景：已知一个字符串S和一个模式串P，查找P在S中的位置？
字符串S： i指向当前字符
字符串P： j指向当前字符

暴力搜索

思路：逐个字符匹配即可。
问题：对于已知的情况会出现反复对比的操作，效率降低

KMP

思路：对模式串P进行分析，使得当S的一部分和P不匹配时，可以快速略过已知的不匹配的字符
做法：从模式串P中得到next数组，用next数组来表示如果当前字符(S[i] != P[j])不匹配，下一个P对应的j的位置, 而i只管一路向后i++

求next数组

理解方式：next其实也可以表示当前字符j之前的0 ~（j-1）位置的字符中，相同的前缀后缀的字符串的数量（长度）。这个数量其实就等于j下一个位置，因为P的索引以0开始。

（这样就说明如果此时j不匹配，但是我前面有一部分是和前缀相同的，就可以不重复匹配了！）
在这里插入图片描述
求取方式：使用递推的方式，即已知next[j]，然后来求next[j+1]，此时有两种情况了。
（next[j] = k：表示0~j-1中相同的前缀后缀，也是j位置不匹配时，下一个要对比的P的位置为k）

如果P[j+1] = P[k], 说明下一个要对比的位置是匹配的，所以往后移动一位即可next[j+1] = next[j]+1 = k+1;(如上图的abab到ababa字串，因为末尾的a和2位置的a相等，所以数量由2+1变为3)
如果P[j+1] ！= P[k]，那么让k = next[k]，即当跳转的(下一个要对比的)字符不匹配的时候，要继续往前跳转（下一个要匹配的字符串如果不匹配时的下一个要匹配的字符串……），直到匹配或者到起始点0（next[0] = -1）

  private static void getNext(int[] next, String P){
        int len = P.length();
        int k = -1;
        int j = 0;
        next[0] = -1;//初始值，对应kj的初始值
        while(j < len-1){
            //k==-1即到头了，没有匹配的了，只好“重头再来”
            if(k == -1 || P.charAt(j) == P.charAt(k)){
                next[j+1] = k + 1;//得到next[j+1]
                k++;
                j++;
            }else{
                k = next[k];
            }
        }
  }

时间复杂度为O(lenP)

KMP匹配

匹配到的时候，i++；匹配不到的时候，j = next[j]找到下一个位置即可。

  private static boolean KMP(String S, String P, int[] next){
      int plen = P.length();
      int slen = S.length();
      int i = 0;//S上的指针
      int j = 0;//P上的指针

      while(i < slen && j < plen){
          //j =- 1说明没有相似的，P模式串从头匹配
          if(j == -1 || S.charAt(i) == P.charAt(j)){
              i++;j++;
          }else{
              //当前不相等时，下一个要匹配的模式串P的位置
              j = next[j];
          }
      }
      // return i-j
      if(j == plen){
           System.out.println(i-j);
           return true;
        }

      return false;
  }

总体时间复杂度O（lenS+lenP），使用空间换时间的思路，next数组的空间为O（lenP）

String的indexOf()

同样是搜索字符串在字符串中的位置，这里提一下indexOf()的实现原理。基本上是稍微优化了的暴力搜索：

 static int indexOf(String source, String target, int fromIndex) {
        final int sourceLength = source.length();
        final int targetLength = target.length();
        if (fromIndex >= sourceLength) {
            return (targetLength == 0 ? sourceLength : -1);
        }
        if (fromIndex < 0) {
            fromIndex = 0;
        }
        if (targetLength == 0) {
            return fromIndex;
        }

        char first = target.charAt(0);
        // 计算出最多比较的次数
        int max = (sourceLength - targetLength);

        for (int i = fromIndex; i <= max; i++) {
            // 寻找在source中出现和target第一个字符相等的位置
            if (source.charAt(i)!= first) {
                while (++i <= max && source.charAt(i) != first);
            }

            if (i <= max) {
                // 找到第一个相等的字符后，从下一个字符开始再比较（下次比较开始的位置）
                int j = i + 1;
                // 除target第一个字符，剩下字符再比较结束的位置
                // 可以理解为：j+(targetLength-1)， 即开始的位置+ target剩下要比较字符的长度
                int end = j + targetLength - 1;
                /* j < end 说明还没有比较完
                 * j < end && source.charAt(j) == target.charAt(k) 是真说明在还没比较完的情况下比较的字符相等，
                 *  那么继续循环，直到条件为false
                 */
                for (int k = 1; j < end && source.charAt(j) == target.charAt(k); j++, k++);

                // 上面循环结束时 j刚好等于结束比较的位置，那么就返回上面找到的target第一个字符相等的位置
                if (j == end) {
                    return i;
                }
            }
        }
        return -1;
    }