字符串算法

骆驼整理说

已于 2022-12-12 13:46:22 修改

阅读量1.5k

点赞数 1

分类专栏：数据结构和算法文章标签：算法

于 2022-02-15 09:56:38 首次发布

本文链接：https://blog.csdn.net/xing_jian1/article/details/122937027

版权

数据结构和算法专栏收录该内容

3 篇文章 0 订阅

订阅专栏

字符串匹配算法

BF算法,是Brute Force(暴力算法)的缩写，是一种字符串匹配算法。

算法步骤

问题：两个字符串a和b,判断b是否是a的子串，如果是请返回b在a中第一次出现的位置。
1.第一轮，从字符串a的首位开始，把a和b的字符逐个比较，a的首位字符是a，b的首位字符是b，不匹配。
2.第二轮，把字符串b后移动一位，从a字符串第二位开始逐个对比。a串的第二位和b串的第二位都是b，继续比较，a串的第三位(b)与b串的第三位(c)不匹配。
3.第三轮，再把b串往后移动一位，从a串的第三位开始，与b串依次逐个比较。a串的第三位字符是b，b串的第三位字符也是b，第四位字符是c，b串的第四位字符也是c，第五位都是e，两者匹配
比较完成。由此得出的结论是b串是a串的子串，在主串中第一次出现的位置下标是2。

示例代码

public class test {
    public static void main(String[] args) throws Exception {
        String a = "abbcefgh";
        String b = "bce";
        int num = bruteForceSearchPatternInText(a, b);
    }

    public static int bruteForceSearchPatternInText(String text, String pattern) {
        int sLen = text.length();
        int pLen = pattern.length();
        char[] s = text.toCharArray();
        char[] p = pattern.toCharArray();
        while (sLen < pLen) {
            return -1;
        }
        int i = 0;
        int j = 0;
        while (i < sLen && j < pLen) {
            if (s[i] == p[j]) {
                //如果当前字符匹配成功（即S[i] == P[j]），则i++，j++
                i = i + 1;
                j = j + 1;
            } else {
                //如果失配（即S[i]! = P[j]），令i = i - (j - 1)，j = 0
                i = i - (j - 1);
                j = 0;
            }
        }
        //匹配成功，返回模式串p在文本串s中的位置，否则返回-1
        if (j == pLen) {
            return i - j;
        } else {
            return -1;
        }
    }

}

RK算法

如果 a = "aaaaaaaaaaaaaaaaab" b="aaab";像这种情况每一轮的检查都需要匹配到b串的最后一个字符，才发现不匹配，两个字符串在每一轮都要比较四次，假设a串长度为m，b串长度为n那么在这种极端的情况下，BF算法的最坏时间复杂度是O(mn)，如何让时间复杂度变为O(n) 有什么更优的解决方案呢？用RK算法呀，RK算法全称Rabin-Karp是由算法的两位发明者Rabin和Karp的名字来命名的。BF算法只是对两个字符串的所有字符依次比较，而RK算法比较的是两个字符串的哈希值。

RK算法步骤

1.生成b串的hashcode
2.生成a串中第一个等长子串的hashcode(abb的hashcode)
3.比较两个hashcode
4.a串中第二个等长子串的hashcode(bbc的hashcode)
5.比较两个hashcode
6.生成a串当中第三个等长子串的hashcode(bce的hashcode)
7.比较两个hashcode
8.依次对比，直到找到两个相同的hashcode，然后像BF算法那样，对两个相同hashcode的字符串逐个字符比较，最终判断两个字符串匹配。

示例:

public class test {
    public static void main(String[] args) throws Exception {
        String str = "aacdesadsdfer";
        String pattern = "adsd";
        System.out.println("第一次出现的位置:" + rabinKarp(str, pattern));
    }

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

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

    private static int nextHash(String str, int hash, int index, int n) {
        hash -= str.charAt(index) - 'a';
        hash += str.charAt(index + n) - 'a';
        return hash;
    }

    private static boolean compareString(int i, String str, String pattern) {
        String strSub = str.substring(i, i + pattern.length());
        return strSub.equals(pattern);
    }

}

RK算法缺点

RK算法计算单个子串hash的时间复杂度是O(n),但是由于后续的子串hash是增量计算，所以总的时间复杂度是O(n)。那么RK算法有什么不足之处呢，RK算法的缺点在于哈希冲突，每次hash冲突的时候，RK算法都要对子串和b串进行逐个字符的比较，如果冲突太多，RK算法就退化成了BF算法。

KMP

KMP全称为Knuth Morris Pratt算法，三个单词分别是三个作者的名字。KMP是一种高效的字符串匹配算法，用来在主字符串中查找模式字符串的位置(比如在"hello,world"主串中查找"world"模式串的位置)。

KMP算法的高效体现在哪

高效性是通过和其他字符串搜索算法对比得到的，在这里拿BF(Brute Force)算法做一下对比。BF算法是一种最朴素的暴力搜索算法。它的思想是在主串的[0, n-m]区间内依次截取长度为m的子串，看子串是否和模式串一样(n是主串的长度，m是子串的长度)。BF的时间复杂度是O(N乘以N)，存在很大优化空间。当模式串和主串匹配时，遇到模式串中某个字符不能匹配的情况，对于模式串中已经匹配过的那些字符，如果我们能找到一些规律，将模式串多往后移动几位，而不是像BF算法一样，每次把模式串移动一位，就可以提高算法的效率。比如说在"ababaababacd"中查找"ababac"，可以避免一些字符之间的比较。

KMP算法的next数组

明确next数组的含义 : next数组用来存模式串中每个前缀最长的能匹配前缀子串的结尾字符的下标。 next[i] = j 表示下标以i-j为起点，i为终点的后缀和下标以0为起点，j为终点的前缀相等，且此字符串的长度最长。用符号表示为p[0j] == p[i-ji]。下面以"ababacd"模式串为例，给出这个串的next数组。

算法流程

举例来说，有一个字符串"BBC ABCDAB ABCDABCDABDE"，我想知道，里面是否包含另一个字符串"ABCDABD"？

字符串"BBC ABCDAB ABCDABCDABDE"的第一个字符与搜索词"ABCDABD"的第一个字符，进行比较。B与A不匹配，搜索词后移一位。
然后第二个字符B与A不匹配，搜索词再往后移。直到字符串有一个字符，与搜索词的第一个字符相同为止。
然后比较字符串和搜索词的下一个字符，还是相同。直到字符串有一个字符，与搜索词对应的字符不相同为止，这时，最自然的反应是，将搜索词整个后移一位，再从头逐个比较。这样做虽然可行，但是效率很差，因为你要把"搜索位置"移到已经比较过的位置，重比一遍。
已知空格与D不匹配时，前面六个字符"ABCDAB"是匹配的。查表可知，最后一个匹配字符B对应的"部分匹配值"为2，因此按照下面的公式算出向后移动的位数：移动位数 = 已匹配的字符数 - 对应的部分匹配值，因为 6 - 2 等于4，所以将搜索词向后移动4位。
然后发现空格与Ｃ不匹配，搜索词还要继续往后移。这时，已匹配的字符数为2（"AB"），对应的"部分匹配值"为0。所以，移动位数 = 2 - 0，结果为 2，于是将搜索词向后移2位。
然后空格与A不匹配，继续后移一位。
逐位比较，直到发现C与D不匹配。于是，移动位数 = 6 - 2，继续将搜索词向后移动4位。
逐位比较，直到搜索词的最后一位，发现完全匹配，于是搜索完成。如果还要继续搜索（即找出全部匹配），移动位数 = 7 - 0，再将搜索词向后移动7位，这里就不再重复了。

KMP的时间复杂度

KMP的时间复杂度是O(n)。

示例

 /**
     * KMP算法
     *
     * @param ss 主串
     * @param ps 模式串
     * @return 如果找到，返回在主串中第一个字符出现的下标，否则为-1
     */
    public static int KMP(String ss, String ps) {
        char[] s = ss.toCharArray();
        char[] p = ps.toCharArray();
        int i = 0; // 主串的位置
        int j = 0; // 模式串的位置
        int[] next = getNext(ps);
        while (i < s.length && j < p.length) {
            //①如果j=-1，或者当前字符匹配成功（即S[i]==P[j]），都令i++，j++
            if (j == -1 || s[i] == p[j]) { // 当j为-1时，要移动的是i，当然j也要归0
                i++;
                j++;
            } else {
                //②如果j!=-1，且当前字符匹配失败（即S[i]!=P[j]），则令i不变，j=next[j]，j右移j-next[j]
                j = next[j];
            }
        }
        if (j == p.length) {
            return i - j;
        } else {
            return -1;
        }
    }

BM匹配算法

BM算法也是一种精确字符串匹配算法，它采用从右向左比较的方法，同时应用到了两种启发式规则，即坏字符规则和好后缀规则，来决定向右跳跃的距离。基本思路就是从右往左进行字符匹配，遇到不匹配的字符后从坏字符表和好后缀表找一个最大的右移值，将模式串右移继续匹配。

替换空格

请实现一个函数，将一个字符串中的每个空格替换成“%20”。例如，当字符串为We Are Happy.则经过替换之后的字符串为We%20Are%20Happy。

public class Solution {
        public String replaceSpace(StringBuffer str) {
            StringBuffer res = new StringBuffer();
            int len = str.length() - 1;
            for (int i = len; i >= 0; i--) {
                if (str.charAt(i) == ' ')
                    res.append("02%");
                else
                    res.append(str.charAt(i));
            }
            return res.reverse().toString();
        }
    }

最长公共前缀

编写一个函数来查找字符串数组中的最长公共前缀。如果不存在公共前缀，返回空字符串 "" 例如：输入["flowers"," flow","flight"] 输出："fl"

public class test {
    public class Solution {
        public String longestCommonPrefix(String[] strs) {
            if (strs == null || strs.length == 0)
                return "";
            Arrays.sort(strs);
            char[] first = strs[0].toCharArray();
            char[] last = strs[strs.length - 1].toCharArray();
            StringBuffer res = new StringBuffer();
            int len = first.length < last.length ? first.length : last.length;
            int i = 0;
            while (i < len) {
                if (first[i] == last[i]) {
                    res.append(first[i]);
                    i++;
                } else
                    break;
            }
            return res.toString();
        }
    }

}