精华内容
下载资源
问答
  • 字符串相似度比较算法,可比较不同长度的任意两个字符串的相似度,以百分比显示。
  • 中文文本相似度匹配算法 simHash 海明距离 IK分词 完整的可运行的示例代码 包含simHash 算法,使用IK 对中文文本进行分词处理
  • 字符串相似度算法

    2015-07-16 17:58:34
    两个字符串,计算出两个字符串相似度,用于模糊匹配,很简单的小例子
  • 字符串相似度比对JAVA

    2016-10-22 18:09:06
    就是一个简单的字符串相似度比较的方法,暂时还不知道有没有更好的方法,大家先看看,有更好的希望分享一下
  • 对输入的文本信息与库里面的字符进行相似度匹配,得出最接近的结果
  • 主要介绍了C#实现的字符串相似度对比类,本文直接给出类实现代码,代码中包含详细注释,需要的朋友可以参考下
  • 使用Levenshtein(莱文斯坦)编辑距离来实现相似度算法 所谓Levenshtein距离,是指两个字串之间,由一个转成另一个所需的最少编辑操作次数,操作包括一切你使用的手段将一个字符串转换成另一个字符串,比如插入一个...

    一、莱文斯坦(相似度)算法

         使用Levenshtein(莱文斯坦)编辑距离来实现相似度算法 所谓Levenshtein距离,是指两个字串之间,由一个转成另一个所需的最少编辑操作次数,操作包括一切你使用的手段将一个字符串转换成另一个字符串,比如插入一个字符、删除一个字符..等等;操作次数越少,说明两个字符串距离Levenshtein Distance越小,表示两个字符串越相似。 
    

    二、具体实现

    /**  * 相似度算法  */ 
    public class LevenshteinAlgorithm {
        public static void main(String[] args) {
            //要比较的两个字符串
            String[] str1 = {"今天星期四","12345667890"};
            String[] str2 = {"今天是星期五","1234567890"};
            for(int i=0;i<str1.length;i++){
                levenshtein(str1[i],str2[i]);
            }
        }
        /**
         *   DNA分析   拼字检查   语音辨识   抄袭侦测
         *
         */
        public static void levenshtein(String str1,String str2) {
            //计算两个字符串的长度。
            int len1 = str1.length();
            int len2 = str2.length();
            //建立上面说的数组,比字符长度大一个空间
            int[][] dif = new int[len1 + 1][len2 + 1];
            //赋初值,步骤B。
            for (int a = 0; a <= len1; a++) {
                dif[a][0] = a;
            }
            for (int a = 0; a <= len2; a++) {
                dif[0][a] = a;
            }
            //计算两个字符是否一样,计算左上的值
            int temp;
            for (int i = 1; i <= len1; i++) {
                for (int j = 1; j <= len2; j++) {
                    if (str1.charAt(i - 1) == str2.charAt(j - 1)) {
                        temp = 0;
                    } else {
                        temp = 1;
                    }
                    //取三个值中最小的
                    dif[i][j] = min(dif[i - 1][j - 1] + temp, dif[i][j - 1] + 1,
                            dif[i - 1][j] + 1);
                }
            }
            System.out.println("字符串\""+str1+"\"与\""+str2+"\"的比较");
            //取数组右下角的值,同样不同位置代表不同字符串的比较
            System.out.println("差异步骤:"+dif[len1][len2]);
            //计算相似度
            float similarity =1 - (float) dif[len1][len2] / Math.max(str1.length(), str2.length());
            System.out.println("相似度:"+getPercentValue(similarity));
        }
        public static String getPercentValue( float similarity){
            NumberFormat fmt = NumberFormat.getPercentInstance();
            fmt.setMaximumFractionDigits(2);//最多两位百分小数,如25.23%
            return fmt.format(similarity);
        }
        //得到最小值
        private static int min(int... is) {
            int min = Integer.MAX_VALUE;
            for (int i : is) {
                if (min > i) {
                    min = i;
                }
            }
            return min;
        } }
    

    三、运行结果

    字符串"今天星期四"与"今天是星期五"的比较
    差异步骤:2
    相似度:66.67%
    字符串"12345667890"与"1234567890"的比较
    差异步骤:1
    相似度:90.91%

    下载源码完整项目http://www.zrscsoft.com/sitepic/12050.html

    展开全文
  • 字符串相似度计算算法

    千次阅读 2019-01-06 10:33:40
    1. 字符串子查找算法KMP 给定一个主(以 S 代替)和模式(以 P 代替),要求找出 P 在 S 中出现的位置,此即的模式匹配问题。Knuth-Morris-Pratt 算法(简称 KMP)是解决这一问题的常用算法之一。 ...

    本文参考:https://zhuanlan.zhihu.com/p/36892462https://zhuanlan.zhihu.com/p/33567268

    1. 字符串子串查找算法KMP

    给定一个主串(以 S 代替)和模式串(以 P 代替),要求找出 P 在 S 中出现的位置,此即串的模式匹配问题。Knuth-Morris-Pratt 算法(简称 KMP)是解决这一问题的常用算法之一。

    KMP算法与其他字符串子串查找的典型的区别是它先计算子串本身存在的一些相关信息,这样可以保证每次匹配不用从最开始位置查找,而是从最佳的位置开始匹配,从而提高了查找的效率,保证复杂度在O(n+m)规模。KMP算法的精华部分就在于求模式匹配的next数组,如果对状态机有所了解,就能很好的理解这一思想

                                    

    代码实现:

    class Solution:
        def getnext(self, pstr):
            pstrlen = len(pstr)
            next = [-1] * pstrlen
            i, k = 0, -1
            while i < pstrlen - 1:
                # k = -1时说明i已经在最最左边了,下一步只能往右移动,所以i和k都加1
                # pstr[i] = pstr[k]时,说明后缀和前缀匹配的长度增加,所以i和k都加1
                if k == -1 or pstr[i] == pstr[k]:
                    i += 1
                    k += 1
    
                    # 为了减少重复计算,当两个字符相等时跳过该位置
                    if pstr[i] == pstr[k]:
                        next[i] = next[k]
                    else:
                        next[i] = k
                else:
                    # 当pstr[i] != pstr[k]时,根据next定义,此时k要跳到next[k]位置
                    k = next[k]
    
            return next
            
    
        def strStr(self, tstr, pstr):
            """
            :type tstr: str
            :type pstr: str
            :rtype: int
            """
            if len(pstr) < 1:
                return 0
            if len(tstr) < 1:
                return -1
    
            pstrlen = len(pstr)
            tstrlen = len(tstr)
            next = self.getnext(pstr)
            print(next)
    
            i, j = 0, 0
            while i < tstrlen and j < pstrlen:
                if j == -1 or tstr[i] == pstr[j]:
                    i += 1
                    j += 1
                else:
                    j = next[j]
    
            if j == pstrlen:
                return i - j
            return -1

    具体算法解释可以参考:https://www.cnblogs.com/yjiyjige/p/3263858.html

    2.最长连续公共子序列

    要求两个字符串的最长连续公共子序列,一般采用的方法是后缀数组法,即先分别求出两个串的后缀数组,然后比较它们之间的连续公共长度。这个有个处理技巧就是为了确认哪个后缀数组属于哪个串,需要在其中一个串后面贴一个标签,避免混淆。

                                         

    当然另一种是使用动态规划进行求解,因此求出问题的状态转移方程至关重要。下面是求解最长连续公共子序列的状态转移方程,知道了状态转移方程,求解就变得很简单了。

                                                                       f(m, n) = \begin{cases} & \text{ 0 }, \quad \quad \quad \quad \quad \quad x_m \not\equiv y_n \\ & \text{ f(m-1, n-1) + 1 }, x_m = y_n \end{cases}

    class Solution:
        def ConsecutiveLCS(self,s1,s2):
            s1Len=len(s1)
            s2Len=len(s2)
            arr=[[0]*(s2Len+1) for i in range(s1Len+1)]
    
            res=0
            for i in range(1,s1Len+1):
                for j in  range(1,s2Len+1):
                    if s1[i-1]==s2[j-1]:
                        arr[i][j]=arr[i-1][j-1]+1
                        if res<arr[i][j]:
                            res=arr[i][j]
                    else:
                        arr[i][j]=0
    
            return res

    3.最长公共子序列

    要求两个串的公共子序列,则这些子序列不一定是连续的,如下图所示。

    对于这类问题通常的解法是采用动态规划,状态转移方程如下所示:

                                                       f(m, n) = \begin{cases} & \text{ max(f(m, n-1), f(m-1, n)) }, x_m \not\equiv y_n \\ & \text{ f(m-1, n-1) + 1 }, \quad \quad \quad \quad x_m = y_n \end{cases}

    class Solution:
        def LCS(self,s1,s2):
            s1Len=len(s1)
            s2Len=len(s2)
            arr=[[0]*(s2Len+1) for i in range(s1Len+1)]
    
            for i in range(1,s1Len+1):
                for j in  range(1,s2Len+1):
                    if s1[i-1]==s2[j-1]:
                        arr[i][j]=arr[i-1][j-1]+1
                    else:
                        arr[i][j]=max(arr[i-1][j],arr[i][j-1])
    
            return arr[s1Len][s2Len]
    

    4.编辑距离算法

    编辑距离,又称Levenshtein距离(莱文斯坦距离也叫做Edit Distance),是指两个字串之间,由一个转成另一个所需的最少编辑操作次数,如果它们的距离越大,说明它们越是不同。许可的编辑操作包括将一个字符替换成另一个字符,插入一个字符,删除一个字符。

    在概念中,我们可以看出一些重点那就是,编辑操作只有三种。插入,删除,替换这三种操作,我们有两个字符串,将其中一个字符串经过上面的这三种操作之后,得到两个完全相同的字符串付出的代价是什么就是我们要讨论和计算的。在这里我们设置每经过一次编辑,也就是变化(插入,删除,替换)我们花费的代价都是1。编辑距离的作用主要是用来比较两个字符串的相似度的。

    对于这类问题,我们可以采用动态规划进行解决:用f[m-1,n]+1表示增加操作,f[m,n-1]+1 表示我们的删除操作,f[m-1,n-1]+temp(str1[i] == str2[j],用temp记录它,为0;否则temp记为1)表示我们的替换操作。状态转移方程为:

                                  f(m, n) = \begin{cases} & \text{ min(f(m, n-1)+1, f(m-1, n)+1, f(m-1, n-1)+1))}, x_m \not\equiv y_n \\ & \text{ min(f(m-1, n) + 1, f(m, n-1)+1, f(m-1, n-1)) }, \quad \quad \quad \quad x_m = y_n \end{cases}

    代码:

    class Solution:
        def EditDistance(self,s1,s2):
            s1Len=len(s1)
            s2Len=len(s2)
            arr=[[0]*(s2Len+1) for i in range(s1Len+1)]
    
            for i in range(s1Len+1):
                arr[i][0]=i
            for i in range(s2Len+1):
                arr[0][i]=i
            for i in range(1,s1Len+1):
                for j in  range(1,s2Len+1):
                    tmp=1
                    if s1[i-1]==s2[j-1]:
                        tmp=0
                    arr[i][j]=min([arr[i][j-1]+1,arr[i-1][j]+1,arr[i-1][j-1]+tmp])
            return arr[s1Len][s2Len]

    5.Jaccard相似度(杰卡德相似度)

    杰卡德相似度,指的是文本A与文本B中交集的字数除以并集的字数,公式非常简单:

                                                                                      J= 1-\frac{\left |A\cap B\right |}{\left |A\cup B\right |}

    例:计算“荒野求生”和“绝地求生”的杰卡德相似度。

    因为它们交集是{求,生},并集是{荒,野,求,生,绝,地},所以它们的杰卡德相似度=2/6=1/3。

    杰卡德相似度与文本的位置、顺序均无关,比如“王者荣耀”和“荣耀王者”的相似度是100%。无论“王者荣耀”这4个字怎么排列,最终相似度都是100%。

    在某些情况下,会先将文本分词,再以词为单位计算相似度。比如将“王者荣耀”切分成“王者/荣耀”,将“荣耀王者”切分成“荣耀/王者”,那么交集就是{王者,荣耀},并集也是{王者,荣耀},相似度恰好仍是100%。

    适用场景

    1)对字/词的顺序不敏感的文本,比如前述的“零售批发”和“批发零售”,可以很好地兼容。

    2)长文本,比如一篇论文,甚至一本书。如果两篇论文相似度较高,说明交集比较大,很多用词是重复的,存在抄袭嫌疑。

    不适用场景

    1)重复字符较多的文本,比如“这是是是是是是一个文本”和“这是一个文文文文文文本”,这两个文本有很多字不一样,直观感受相似度不会太高,但计算出来的相似度却是100%(交集=并集)。

    2)对文字顺序很敏感的场景,比如“一九三八年”和“一八三九年”,杰卡德相似度是100%,意思却完全不同。

    展开全文
  • Java字符串相似度匹配

    万次阅读 2018-11-16 00:30:31
    //要比较的两个字符串 String str1 = "鞋子不能在实体店买"; String str2 = "不能在实体店买鞋子"; levenshtein(str1.toLowerCase(),str2.toLowerCase()); } /** * * @param str1 * @param str2 */ ...

    原文:http://wdhdmx.iteye.com/blog/1343856#bc2319361

    package com.xfl.boot.common.utils;
    
    /**
     * Created by XFL
     * time on 2018/11/16 0:10
     * description:
     */
    public class SimilarityUtils {
        public static void main(String[] args) {
            //要比较的两个字符串
            String str1 = "鞋子不能在实体店买";
            String str2 = "不能在实体店买鞋子";
            levenshtein(str1.toLowerCase(),str2.toLowerCase());
        }
    
        /**
         *
         * @param str1
         * @param str2
         */
        public static void levenshtein(String str1,String str2) {
            //计算两个字符串的长度。
            int len1 = str1.length();
            int len2 = str2.length();
            //建立上面说的数组,比字符长度大一个空间
            int[][] dif = new int[len1 + 1][len2 + 1];
            //赋初值,步骤B。
            for (int a = 0; a <= len1; a++) {
                dif[a][0] = a;
            }
            for (int a = 0; a <= len2; a++) {
                dif[0][a] = a;
            }
            //计算两个字符是否一样,计算左上的值
            int temp;
            for (int i = 1; i <= len1; i++) {
                for (int j = 1; j <= len2; j++) {
                    if (str1.charAt(i - 1) == str2.charAt(j - 1)) {
                        temp = 0;
                    } else {
                        temp = 1;
                    }
                    //取三个值中最小的
                    dif[i][j] = min(dif[i - 1][j - 1] + temp, dif[i][j - 1] + 1,
                            dif[i - 1][j] + 1);
                }
            }
            System.out.println("字符串\""+str1+"\"与\""+str2+"\"的比较");
            //取数组右下角的值,同样不同位置代表不同字符串的比较
            System.out.println("差异步骤:"+dif[len1][len2]);
            //计算相似度
            float similarity =1 - (float) dif[len1][len2] / Math.max(str1.length(), str2.length());
            System.out.println("相似度:"+similarity);
        }
    
        //得到最小值
        private static int min(int... is) {
            int min = Integer.MAX_VALUE;
            for (int i : is) {
                if (min > i) {
                    min = i;
                }
            }
            return min;
        }
    }
    
    

    在这里插入图片描述

    展开全文
  • 平时的编码中,我们经常需要判断两个文本的相似性,不管是用来做文本纠错或者去重等等,那么我们应该以什么维度来判断相似性呢?这些算法又怎么实现呢?这篇文章对常见的计算方式做一个记录。Leven...

    平时的编码中,我们经常需要判断两个文本的相似性,不管是用来做文本纠错或者去重等等,那么我们应该以什么维度来判断相似性呢?这些算法又怎么实现呢?这篇文章对常见的计算方式做一个记录。Levenshtein 距离,又称编辑距离,指的是两个字符串之间,由一个转换成另一个所需的最少编辑操作次数。许可的编辑操作包括将一个字符替换成另一个字符,插入一个字符,删除一个字符。编辑距离的算法是首先由俄国科学家Levenshtein提出的,故又叫Levenshtein Distance。我们在做数据系统的时候,经常会用到模糊搜索,但是,数据库提供的模糊搜索并不具备按照相关度进行排序的功能。现在提供一个比较两个字符串相似度的方法。通过计算出两个字符串的相似度,就可以通过Linq在内存中对数据进行排序和筛选,选出和目标字符串最相似的一个结果。本次所用到的相似度计算公式是 相似度=Kqq/(Kqq+Krr+Kss) (Kq > 0 , Kr>=0,Ka>=0) 其中,q是字符串1和字符串2中都存在的单词的总数,s是字符串1中存在,字符串2中不存在的单词总数,r是字符串2中存在,字符串1中不存在的单词总数. Kq,Kr和ka分别是q,r,s的权重,根据实际的计算情况,我们设Kq=2,Kr=Ks=1. 根据这个相似度计算公式,得出以下程序代码:

    
    /// <summary>
     /// 获取两个字符串的相似度
    /// </summary>
     /// <param name=”sourceString”>第一个字符串</param>
     /// <param name=”str”>第二个字符串</param>
     /// <returns></returns>
     public static decimal GetSimilarityWith(this string sourceString, string str)
     {
    
    decimal Kq = 2;
     decimal Kr = 1;
     decimal Ks = 1;
    
    char[] ss = sourceString.ToCharArray();
     char[] st = str.ToCharArray();
    
    //获取交集数量
    int q = ss.Intersect(st).Count();
     int s = ss.Length – q;
     int r = st.Length – q;
    
    return Kq * q / (Kq * q + Kr * r + Ks * s);
     }
    
     
    
    
    

    这就是计算字符串相似度的方法,但是实际应用时,还需要考虑到同义词或近义词的情况发生, 如“爱造人小说阅读的更新最快”和“爱造人小说阅读地更新最快” 。两个字符串在一定意义上说其实是相同的,如果使用上述方法计算就会出现不准确的情况。所以在实际应用的时候,我们需要替换同义词或近义词,计算替换后的相似度。如果是近义词,需要综合替换近义词前和近义词后的计算结果,得出两个字符串的实际相似度。

    展开全文
  • golang 字符串相似度算法

    千次阅读 2020-09-11 11:13:04
    题目:一个字符串可以通过增加一个字符,删除一个字符,...字符串相似度算法可以使用 Levenshtein Distance算法(中文翻译:编辑距离算法) 这算法是由俄国科学家Levenshtein提出的。其步骤 Step Description 1 ...
  • 首先对三种基本字符串匹配算法进行了详细分析和说明,再编程实现。创新拓展研究了Boyer-Moore算法,进行了分析和编程实现。让四种算法对数据量极大的文本,进行子串的查询处理,并分析算法运行时间效率,并对所有...
  • Java字符串匹配相似度算法

    千次阅读 2018-12-19 11:34:50
    * 采用动态规划的方法(字符串匹配相似度) * @param source 源 * @param target 要匹配字符串 * @return */ public static int EditDistance(String source, String target) { char[] source...
  • 原文链接:https://blog.csdn.net/baidu_23086307/article/details/53020566   C++版 #include &lt;iostream&gt; #include &lt;vector&gt;...//算法 int ldistance(const s...
  • 评价字符串相似度最常见的办法就是: 把一个字符串通过插入、删除或替换这样的编辑操作,变成另外一个字符串,所需要的最少编辑次数,这种就是编辑距离(edit distance)度量方法,也称为Levenshtein距离。 海明...
  • #pragma once #ifndef SIMILARITY_H #define SIMILARITY_H #include #include std::vectorstd::string getStringArray(std::string& SA) { std::vectorstd::string tmp; for (size_t i = 0;...
  • java 字符串相似度算法

    千次阅读 2018-09-27 11:01:38
    * 获取两字符串相似度 */ public static float getSimilarityRatio(String str, String target) { // 1-莱茵斯坦距离/最大字符串长度 return 1 - (float) levenshiteinDistance(str, target) / Math.max...
  • Java 实现推荐系统 两个字符串 余弦相似度 算法
  • public static float ...//计算两个字符串的长度。 int len1 = str1.Length; int len2 = str2.Length; //建立上面说的数组,比字符长度大一个空间 int[,] dif = new int[len1 + 1,len2 + 1]; //...
  • 在搞验证码识别的时候需要比较字符代码的相似度用到“编辑距离算法”,关于原理和C#实现做个记录。 据百度百科介绍: 编辑距离,又称Levenshtein距离(也叫做Edit Distance),是指两个字串之间,由一个转成另一个...
  • 字符串相似度计算工具和算法

    千次阅读 2020-07-10 22:19:17
    介绍:JavaWuzzy是Java版的FuzzyWuzzy,用于计算字符串之间的匹配度。 FuzzySearch.ratio(String s1, String s2) 全匹配,对顺序敏感 FuzzySearch.partialRatio(String s1, String s2) 搜索匹配(部分匹配),对顺序...
  • 如何能够计算两个字符串相似度,比如agccta和acctg这两个字符串,如果可以能得到不相同的位置就很好
  • MySql字符串相似匹配

    2018-10-22 15:51:14
    亲测可用,mysql字符串相似度匹配函数。下载后直接在mysql中可以测试运行。
  • 编辑距离指的就是,将一个字符串转化成另一个字符串,需要的最少编辑操作次数(比如增加一个字符、删除一个字符、替换一个字符)。编辑距离越大,说明两个字符串的相似程度越小;相反,编辑距离就越小,说明两个...
  • 字符串的近似匹配算法Okay. So what exactly is the problem here? 好的。 那到底是什么问题呢? How often have we come across situations where we need to know if two strings are 'similar' but not ...
  • 中文相似度匹配算法

    千次阅读 2017-12-18 22:12:38
    经典算法1---相似度--模糊查询,查抄袭,语言识别 转载 2016年07月11日 21:57:53 标签: 经典算法 / java / 8878 编辑 删除 from http://wdhdmx.iteye.com/blog/1343856#bc2319361 1.百度百科介绍: ...
  • 在分析两类题型的特点及目前采用的评测方法的优缺点的基础上,提出使用字符串相似度算法对程序设计题进行评判,并给出了评分过程的整体流程图。经过实际的使用,证明该方法是目前采用方法的一个很好补充,使评分的...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 6,884
精华内容 2,753
关键字:

字符串相似度匹配算法