精华内容
下载资源
问答
  • 字符串相似度算法

    2015-07-16 17:58:34
    两个字符串,计算出两个字符串相似度,用于模糊匹配,很简单的小例子
  • 字符串相似度算法 字符串相似度算法 字符串相似度算法 字符串相似度算法 相似度 字符串
  • 使用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

    展开全文
  • 字符串相似度比较算法,可比较不同长度的任意两个字符串的相似度,以百分比显示。
  • 计算字符串相似度(支持中英文,编辑距离算法,余弦,繁体转简体)的简单demo,可以直接运行查看结果。。。。
  • java字符串相似度算法

    2020-09-03 22:38:37
    主要介绍了java字符串相似度算法,是Java实现比较典型的算法,具有一定参考借鉴价值,需要的朋友可以参考下
  • 字符串相似度算法 -- 余弦相似

    千次阅读 2019-04-15 10:43:55
    关于字符串相似度, 网上有很多算法,我在项目中用到过编辑距离算法 和余弦相似度算法. 编辑距离算法是根据单个字符来比较的,是一个字符串替换成另一个字符串的难度系数, 对距离很敏感. 两个句子中的字词一样, 但是...

    关于字符串相似度, 网上有很多算法,我在项目中用到过编辑距离算法余弦相似度算法.

    • 编辑距离算法是根据单个字符来比较的,是一个字符串替换成另一个字符串的难度系数, 对距离很敏感. 两个句子中的字词一样, 但是位置变化, 编辑距离算出来的相似的也变化,而且对比较短的字符串不友好,例如:"中国你好"和"你好中国"两个字符串的相似度是0;"你好呀中国"和"中国你好呀"相似度0.19
    • 余弦相似度是一词为单位的, 对距离不敏感. "中国你好"和"你好中国"的相似度是1, 因为他们包含相同的词语且词语数量一样.

    可以根据具体的使用场景,选择…

    下面是余弦相似的的Java实现:对来个字符串比较需要先切词,在比较, 切词工具也很多,可以自行选择

    public static double getSimilarity(String s1, String s2) {
            if (StringUtils.isEmpty(s1) && StringUtils.isEmpty(s2)) {
                return 1;
            }
            if (StringUtils.isEmpty(s1) || StringUtils.isEmpty(s2)) {
                return 0;
            }
            // 先切词
            List<String> segment1 = AliboSeg.segmentMergeNum(s1);
            List<String> segment2 =  AliboSeg.segmentMergeNum(s2);
            return getSimilarity(segment1, segment2);
        }
    
    	// 切好词的集合, 直接比较
        public static double getSimilarity(List<String> word1, List<String> word2) {
            if ((null == word1  && null == word2)) {
                return 1;
            }
            if (null == word1  || null == word2) {
                return 0;
            }
            if (word1.size() == 0 && word2.size() == 0) {
                return 1;
            }
            if (word1.size() == 0 || word2.size() == 0) {
                return 0;
            }
            // 算出每个词在自己的句子中出现几次
            Map<String, AtomicInteger> map1 = getFrequency(word1);
            Map<String, AtomicInteger> map2 = getFrequency(word2);
            // 得到两个句子中的所有词语
            Set<String> allWords = new HashSet<>();
            allWords.addAll(word1);
            allWords.addAll(word2);
            AtomicInteger ab = new AtomicInteger();
            AtomicInteger aa = new AtomicInteger();
            AtomicInteger bb = new AtomicInteger();
            // 循环所有词,计算每个词出现的频率,计算向量;
            for (String word : allWords) {
                //看同一词在a、b两个集合出现的次数
                AtomicInteger atomicInteger1 = map1.get(word);
                int x1 = 0;
                if (null != atomicInteger1) {
                    x1 = atomicInteger1.intValue();
                }
                AtomicInteger atomicInteger2 = map2.get(word);
                int x2 = 0;
                if (null != atomicInteger2) {
                    x2 = atomicInteger2.intValue();
                }
                //x1 * x2
                int f0 = x1 * x2;
                ab.addAndGet(f0);
                //(x1)^2
                int f1 = x1 * x1;
                aa.addAndGet(f1);
                //(x2)^2
                int f2 = x2 * x2;
                bb.addAndGet(f2);
            }
            //|a| 对aa开方
            double aaa = Math.sqrt(aa.doubleValue());
            //|b| 对bb开方
            double bbb = Math.sqrt(bb.doubleValue());
            //使用BigDecimal保证精确计算浮点数
            //double aabb = aaa * bbb;
            BigDecimal aabb = BigDecimal.valueOf(aaa).multiply(BigDecimal.valueOf(bbb));
            //similarity=a.b/|a|*|b|
            //divide参数说明:aabb被除数,2表示小数点后保留2位,最后一个表示用标准的四舍五入法
            double cos = BigDecimal.valueOf(ab.get()).divide(aabb, 2, BigDecimal.ROUND_HALF_UP).doubleValue();
            return cos;
        }
    
        // 获取每个词语在集合中出现的次数
        private static Map<String, AtomicInteger> getFrequency(List<String> wordList) {
            Map<String, AtomicInteger> freq = new HashMap<>();
            wordList.forEach(word -> freq.computeIfAbsent(word, k -> new AtomicInteger()).incrementAndGet());
            return freq;
        }
    
    展开全文
  • 字符串相似度比对JAVA

    2016-10-22 18:09:06
    就是一个简单的字符串相似度比较的方法,暂时还不知道有没有更好的方法,大家先看看,有更好的希望分享一下
  • 比较两个字符串相似度,利用Levenshein算法计算出两个字符串的最小编辑距离,根据最小编辑距离得出相似度,例如: 字符串1:1234 字符串2:51234,则他们的相似度为:4/5。
  • golang 字符串相似度算法

    千次阅读 2020-09-11 11:13:04
    题目:一个字符串可以通过增加一个字符,删除一个字符,...字符串相似度算法可以使用 Levenshtein Distance算法(中文翻译:编辑距离算法) 这算法是由俄国科学家Levenshtein提出的。其步骤 Step Description 1 ...

    在使用cobra的时候,如果输入的command不对,会提示:

    $ go run main.go pring katy
    Error: unknown command "pring" for "cobra"
    
    Did you mean this?
            print

    很好奇这个怎么做的,没想到这竟然是一个字符串相似度的算法题 。

     

    题目: 一个字符串可以通过增加一个字符,删除一个字符,替换一个字符得到另外一个字符串,假设,我们把从字符串A转换成字符串B,前面3种操作所执行的最少次数称为AB相似度
    如  abc adc  度为 1
          ababababa babababab 度为 2
          abcd acdb 度为2


     字符串相似度算法可以使用 Levenshtein Distance算法(中文翻译:编辑距离算法) 这算法是由俄国科学家Levenshtein提出的。其步骤

    StepDescription
    1Set n to be the length of s.
    Set m to be the length of t.
    If n = 0, return m and exit.
    If m = 0, return n and exit.
    Construct a matrix containing 0..m rows and 0..n columns.
    2Initialize the first row to 0..n.
    Initialize the first column to 0..m.
    3Examine each character of s (i from 1 to n).
    4Examine each character of t (j from 1 to m).
    5If s[i] equals t[j], the cost is 0.
    If s[i] doesn't equal t[j], the cost is 1.
    6Set cell d[i,j] of the matrix equal to the minimum of:
    a. The cell immediately above plus 1: d[i-1,j] + 1.
    b. The cell immediately to the left plus 1: d[i,j-1] + 1.
    c. The cell diagonally above and to the left plus the cost: d[i-1,j-1] + cost.
    7After the iteration steps (3, 4, 5, 6) are complete, the distance is found in cell d[n,m].

     代码位置:https://github.com/spf13/cobra/cobra.go#ld

    // ld compares two strings and returns the levenshtein distance between them.
    func ld(s, t string, ignoreCase bool) int {
    	if ignoreCase {
    		s = strings.ToLower(s)
    		t = strings.ToLower(t)
    	}
    	d := make([][]int, len(s)+1)
    	for i := range d {
    		d[i] = make([]int, len(t)+1)
    	}
    	for i := range d {
    		d[i][0] = i
    	}
    	for j := range d[0] {
    		d[0][j] = j
    	}
    	for j := 1; j <= len(t); j++ {
    		for i := 1; i <= len(s); i++ {
    			if s[i-1] == t[j-1] {
    				d[i][j] = d[i-1][j-1]
    			} else {
    				min := d[i-1][j]
    				if d[i][j-1] < min {
    					min = d[i][j-1]
    				}
    				if d[i-1][j-1] < min {
    					min = d[i-1][j-1]
    				}
    				d[i][j] = min + 1
    			}
    		}
    
    	}
    	return d[len(s)][len(t)]
    }

     

    展开全文
  • 评价字符串相似度最常见的办法就是: 把一个字符串通过插入、删除或替换这样的编辑操作,变成另外一个字符串,所需要的最少编辑次数,这种就是编辑距离(edit distance)度量方法,也称为Levenshtein距离。 海明...

    字符串的相似性比较应用场合很多,像拼写纠错、文本去重、上下文相似性等。

     

    评价字符串相似度最常见的办法就是:

    把一个字符串通过插入、删除或替换这样的编辑操作,变成另外一个字符串,所需要的最少编辑次数,这种就是编辑距离(edit distance)度量方法,也称为Levenshtein距离。

    海明距离是编辑距离的一种特殊情况,只计算等长情况下替换操作的编辑次数,只能应用于两个等长字符串间的距离度量。

     

    其他常用的度量方法还有 Jaccard distance、J-W距离(Jaro–Winkler distance)、余弦相似性(cosine similarity)、欧氏距离(Euclidean distance)等。

     

    https://github.com/luchaoshuai/fuzzystring-standard

    转载于:https://www.cnblogs.com/luchaoshuai/p/9657887.html

    展开全文
  • NULL 博文链接:https://biansutao.iteye.com/blog/326008
  • 两个字符串相似度算法实现——编辑距离之Levenshtein距离
  • 字符串相似度算法(编辑距离算法)

    千次阅读 2019-04-24 20:56:13
    编辑距离算法前言原理实现 前言 有时候 原理 实现
  • 首先在面试官看简历的期间,除了一个自己定义字符串相似度,并且写出求相似度的算法。 。。。这个确实没听说过,php的similar_text函数也是闻所未闻的。之前看seo的时候,到简单了解了一下页面的相似度,百度算法中...
  • 在搞验证码识别的时候需要比较字符代码的相似度用到“编辑距离算法”,关于原理和C#实现做个记录。 据百度百科介绍: 编辑距离,又称Levenshtein距离(也叫做Edit Distance),是指两个字串之间,由一个转成另一个...
  • 字符串相似度算法是指通过一定的方法,来计算两个不同字符串之间的相似程度。通常会用一个百分比来衡量字符串之间的相似程度。字符串相似度算法被应用于许多计算场景,在诸如数据清洗,用户输入纠错,推荐系统, ...
  • 主要介绍了C#实现的字符串相似度对比类,本文直接给出类实现代码,代码中包含详细注释,需要的朋友可以参考下
  • function xsd(x, y) { var z = 0; x = x.toUpperCase(); y = y.toUpperCase(); x = x.replace('_', ''); y = y.replace('_', ''); if (typeof x == "string") { x = x.split("");... var a
  • Java字符串相似度 一个实现不同字符串相似度和距离度量的库。 当前实现了十二种算法(包括Levenshtein编辑距离和同级,Jaro-Winkler,最长公共子序列,余弦相似性等)。 查看下面的摘要表以获取完整列表... 下载 ...
  • 我需要一个模糊字符串匹配问题的快速解决方案,但没有找到任何易于获取的 JS 实现——因此是这个。 我希望其他人觉得这很有用。 请注意,这是半小时左右的工作,因此其中可能存在错误(不过到目前为止对我来说效果...
  • 字符串相似度 算法 - 莱文斯坦距离 /** * <p> * StringSimilarityUtil<br> * 字符串相似度<br> * 莱文斯坦距离,又称 Levenshtein 距离,是编辑距离的一种。指两个字串之间,由一个转成另一...
  • 原文链接:https://blog.csdn.net/baidu_23086307/article/details/53020566   C++版 #include &lt;iostream&gt; #include &lt;vector&gt;...//算法 int ldistance(const s...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 11,973
精华内容 4,789
关键字:

字符串相似度算法