字符串相似度算法（Levenshtein Distance）

Levenshtein Distance(LD)算法是比较两字符串的相似性。它们的距离就是一个字符串转换成那一个字符串过程中的添加、删除、修改数值，如果s是源字符串souce，t是目标字符串target，比较s和t是否相似，如下：

• 如果s="test"，t="test"，那么LD(str1,str2) = 0。没有经过转换。

• 如果s="test"，t="tent"，那么LD(str1,str2) = 1。str1的"s"转换"n"，转换了一个字符，所以是1。如果它们的距离越大，说明它们越不同。

    Levenshtein distance最先是由俄国科学家Vladimir Levenshtein在1965年发明，用他的名字命名。

    Levenshtein distance可以用来：

• Spell checking(拼写检查)

• Speech recognition(语句识别)

• DNA analysis(DNA分析)

• Plagiarism detection(抄袭检测)

LD算法大概过程：

Steps

Step	Description
1	Set 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.
2	Initialize the first row to 0..n. Initialize the first column to 0..m.
3	Examine each character of s (i from 1 to n).
4	Examine each character of t (j from 1 to m).
5	If s[i] equals t[j], the cost is 0. If s[i] doesn't equal t[j], the cost is 1.
6	Set 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.
7	After the iteration steps (3, 4, 5, 6) are complete, the distance is found in cell d[n,m]

distance头文件

1. class Distance
2. {
3.   public:
4.     int LD (char const *s, char const *t);
5.   private:
6.     int Minimum (int a, int b, int c);
7.     int *GetCellPointer (int *pOrigin, int col, int row, int nCols);
8.     int GetAt (int *pOrigin, int col, int row, int nCols);
9.     void PutAt (int *pOrigin, int col, int row, int nCols, int x);
10. }; 

distance代码文件

1. #include "distance.h"
2. #include <string.h>
3. #include <malloc.h>
5. //****************************
6. // Get minimum of three values
7. //****************************
9. int Distance::Minimum (int a, int b, int c)
10. {
11. int mi;
13.   mi = a;
14.   if (b < mi) {
15.     mi = b;
16.   }
17.   if (c < mi) {
18.     mi = c;
19.   }
20.   return mi;
22. }
24. //**************************************************
25. // Get a pointer to the specified cell of the matrix
26. //************************************************** 
28. int *Distance::GetCellPointer (int *pOrigin, int col, int row, int nCols)
29. {
30.   return pOrigin + col + (row * (nCols + 1));
31. }
33. //*****************************************************
34. // Get the contents of the specified cell in the matrix 
35. //*****************************************************
37. int Distance::GetAt (int *pOrigin, int col, int row, int nCols)
38. {
39. int *pCell;
41.   pCell = GetCellPointer (pOrigin, col, row, nCols);
42.   return *pCell;
44. }
46. //*******************************************************
47. // Fill the specified cell in the matrix with the value x
48. //*******************************************************
50. void Distance::PutAt (int *pOrigin, int col, int row, int nCols, int x)
51. {
52. int *pCell;
54.   pCell = GetCellPointer (pOrigin, col, row, nCols);
55.   *pCell = x;
57. }
59. //*****************************
60. // Compute Levenshtein distance
61. //*****************************
63. int Distance::LD (char const *s, char const *t)
64. {
65. int *d; // pointer to matrix
66. int n; // length of s
67. int m; // length of t
68. int i; // iterates through s
69. int j; // iterates through t
70. char s_i; // ith character of s
71. char t_j; // jth character of t
72. int cost; // cost
73. int result; // result
74. int cell; // contents of target cell
75. int above; // contents of cell immediately above
76. int left; // contents of cell immediately to left
77. int diag; // contents of cell immediately above and to left
78. int sz; // number of cells in matrix
80.   // Step 1 
82.   n = strlen (s);
83.   m = strlen (t);
84.   if (n == 0) {
85.     return m;
86.   }
87.   if (m == 0) {
88.     return n;
89.   }
90.   sz = (n+1) * (m+1) * sizeof (int);
91.   d = (int *) malloc (sz);
93.   // Step 2
95.   for (i = 0; i <= n; i++) {
96.     PutAt (d, i, 0, n, i);
97.   }
99.   for (j = 0; j <= m; j++) {
100.     PutAt (d, 0, j, n, j);
101.   }
103.   // Step 3
105.   for (i = 1; i <= n; i++) {
107.     s_i = s[i-1];
109.     // Step 4
111.     for (j = 1; j <= m; j++) {
113.       t_j = t[j-1];
115.       // Step 5
117.       if (s_i == t_j) {
118.         cost = 0;
119.       }
120.       else {
121.         cost = 1;
122.       }
124.       // Step 6 
126.       above = GetAt (d,i-1,j, n);
127.       left = GetAt (d,i, j-1, n);
128.       diag = GetAt (d, i-1,j-1, n);
129.       cell = Minimum (above + 1, left + 1, diag + cost);
130.       PutAt (d, i, j, n, cell);
131.     }
132.   }
134.   // Step 7
136.   result = GetAt (d, n, m, n);
137.   free (d);
138.   return result;
139.     
140. }