编辑距离及编辑距离算法(求字符的相似度) js版

编辑距离概念描述：

编辑距离，又称Levenshtein距离，是指两个字串之间，由一个转成另一个所需的最少编辑操作次数。许可的编辑操作包括将一个字符替换成另一个字符，插入一个字符，删除一个字符。

例如将kitten一字转成sitting：

1. sitten （k→s）
2. sittin （e→i）
3. sitting （→g）

俄罗斯科学家Vladimir Levenshtein在1965年提出这个概念。

问题：找出字符串的编辑距离，即把一个字符串s1最少经过多少步操作变成编程字符串s2，操作有三种，添加一个字符，删除一个字符，修改一个字符

解析：

首先定义这样一个函数——edit(i, j)，它表示第一个字符串的长度为i的子串到第二个字符串的长度为j的子串的编辑距离。

显然可以有如下动态规划公式：

• if i == 0 且 j == 0，edit(i, j) = 0
• if i == 0 且 j > 0，edit(i, j) = j
• if i > 0 且j == 0，edit(i, j) = i
• if i ≥ 1  且 j ≥ 1 ，edit(i, j) == min{ edit(i-1, j) + 1, edit(i, j-1) + 1, edit(i-1, j-1) + f(i, j) }，当第一个字符串的第i个字符不等于第二个字符串的第j个字符时，f(i, j) = 1；否则，f(i, j) = 0。

举例：edit(4, 2)== min{ edit(4-1, 2) + 1, edit(4, 2-1) + 1, edit(4-1, 2-1) + f(4, 2) }

字符"abcd"到字符"ac"的编辑距离 ==   字符"abcd"到字符"a"的编辑距离+1， 字符"abc"到字符"ac"的编辑距离+1，字符"abc"到字符"a"的编辑距离+0或者1 （如果后面相等就为0，不相等为1）。

代码：

function editDistance(s1,s2) {
//s1[i]表示第一个字符的第i个字符
  var len1=s1.length,len2=s2.length;
  var d=[];
  var i,j;
  /*初始化二维数组，以及定义
   if i == 0 且 j == 0，edit(i, j) = 0
   if i == 0 且 j > 0，edit(i, j) = j
   if i > 0 且j == 0，edit(i, j) = i
   */

  for(i = 0;i <= len1;i++){
    d[i]=[];
    d[i][0] = i;
  }
  for(j = 0;j <= len2;j++){
    d[0][j] = j;
  }
  for(i = 1;i <= len1;i++){
    for(j = 1;j <= len2;j++) {
      var cost = s1[i-1] === s2[j-1] ? 0 : 1;
      var deletion = d[i-1][j] + 1; //删除动作
      var insertion = d[i][j-1] + 1; //增加动作
      var substitution = d[i-1][j-1] + cost; //替换字符，如果相同cost=0；不同cost=1
      d[i][j] = Math.min(deletion,insertion,substitution);
    }
  }
  return d;
}
function getchunkExec(s1,s2) {
  var chunkExec=[];
  var pre;
//生成增量指令 r：替换，a:增加，d删除
  function edit(d,i,j) {
    if(i===0&&j===0)return;

    if(i>0&&j>0&&d[i][j]>d[i-1][j-1]) {
      if(pre&&pre[0]==='r'){
        pre[1]=i-1;
        pre[2]=s2[j-1]+pre[2]
      }else{
        pre=['r',i-1,s2[j-1]]
        chunkExec.push(pre);
      }
      edit(d, i - 1, j - 1)
    }else if(j>0&&d[i][j]>d[i][j-1]){
      if(pre&&pre[0]==='a'){
        pre[1]=s2[j-1]+pre[1]
      }else{
        pre=['a',s2[j-1]]
        chunkExec.push(pre);
      }
      edit(d,i,j-1)
    }else if(i>0&&d[i][j]>d[i-1][j]){
      if(pre&&pre[0]==='d'){
        pre[1]=i-1;
      }else{
        pre=['d',i-1]
        chunkExec.push(pre);
      }
      edit(d,i-1,j)
    }else if(d[i][j]===d[i-1][j-1]) {
      if(pre&&pre[0]==='e'){
        pre[1]=i-1;
      }else{
        pre=['e',i-1]
        chunkExec.push(pre);
      }
      edit(d, i - 1, j - 1)
    }
  }
  var rect=editDistance(s1,s2);
  edit(rect,s1.length,s2.length)

  return chunkExec;
}
//s1 chunk更新
function chunkUpdate(s1,chunkExec){
  var arr=[]
  chunkExec.forEach(function (item) {
    if(item[0]==='r'){
      s1=s1.slice(0,item[1])
      arr.unshift(item[2])
    }else if(item[0]==='a'){
      arr.unshift(item[1])
    }else if(item[0]==='d'){
      s1=s1.slice(0,item[1])
    }else if(item[0]==='e'){
      arr.unshift(s1.slice(item[1]))
      s1=s1.slice(0,item[1])
    }
  })
  return arr.join('');

}

//定义两个字符
var s1="adsddsdsd",s2="abcd";
//生成增量包
var chunkExec=getchunkExec(s1,s2)
//解析增量包
var ns1=chunkUpdate(s1,chunkExec)

console.log(chunkExec);//增量包
console.log(s1,'=>',ns1,ns1===s2);//>abcd true

[ [ 'd', 4 ], [ 'e', 3 ], [ 'r', 1, 'bc' ], [ 'e', 0 ] ]
adsddsdsd => abcd true