算法基本原理：假設我們可以使用d[ i , j ]個步驟（可以使用一個二維數組保存這個值），表示將串s[ 1…i ] 轉換為 串t [ 1…j ]所需要的最少步驟個數，那么，在最基本的情況下，即在i等於0時，也就是說串s為空，那么對應的d[0,j] 就是 增加j個字符，使得s轉化為t，在j等於0時，也就是說串t為空，那么對應的d[i,0] 就是 減少 i個字符，使得s轉化為t。
然后我們考慮一般情況，加一點動態規划的想法，我們要想得到將s[1..i]經過最少次數的增加，刪除，或者替換操作就轉變為t[1..j]，那么我們就必須在之前可以以最少次數的增加，刪除，或者替換操作，使得現在串s和串t只需要再做一次操作或者不做就可以完成s[1..i]到t[1..j]的轉換。所謂的“之前”分為下面三種情況：
1）我們可以在k個操作內將 s[1…i] 轉換為 t[1…j-1]
2）我們可以在k個操作里面將s[1..i-1]轉換為t[1..j]
3）我們可以在k個步驟里面將 s[1…i-1] 轉換為 t [1…j-1]
針對第1種情況，我們只需要在最后將 t[j] 加上s[1..i]就完成了匹配，這樣總共就需要k+1個操作。
針對第2種情況，我們只需要在最后將s[i]移除，然后再做這k個操作，所以總共需要k+1個操作。
針對第3種情況，我們只需要在最后將s[i]替換為 t[j]，使得滿足s[1..i] == t[1..j]，這樣總共也需要k+1個操作。而如果在第3種情況下，s[i]剛好等於t[j]，那我們就可以僅僅使用k個操作就完成這個過程。
最后，為了保證得到的操作次數總是最少的，我們可以從上面三種情況中選擇消耗最少的一種最為將s[1..i]轉換為t[1..j]所需要的最小操作次數。
算法基本步驟：
（1）構造 行數為m+1 列數為 n+1 的矩陣 , 用來保存完成某個轉換需要執行的操作的次數，將串s[1..n] 轉換到 串t[1…m] 所需要執行的操作次數為matrix[n][m]的值；
（2）初始化matrix第一行為0到n，第一列為0到m。
Matrix[0][j]表示第1行第j-1列的值，這個值表示將串s[1…0]轉換為t[1..j]所需要執行的操作的次數，很顯然將一個空串轉換為一個長度為j的串，只需要j次的add操作，所以matrix[0][j]的值應該是j，其他值以此類推。
（3）檢查每個從1到n的s[i]字符；
（4）檢查每個從1到m的s[i]字符；
（5）將串s和串t的每一個字符進行兩兩比較，如果相等，則讓cost為0，如果不等，則讓cost為1（這個cost后面會用到）;
(6)a、如果我們可以在k個操作里面將s[1..i-1]轉換為t[1..j]，那么我們就可以將s[i]移除，然后再做這k個操作，所以總共需要k+1個操作。
b、如果我們可以在k個操作內將 s[1…i] 轉換為 t[1…j-1] ，也就是說d[i,j-1]=k，那么我們就可以將 t[j] 加上s[1..i]，這樣總共就需要k+1個操作。
c、如果我們可以在k個步驟里面將 s[1…i-1] 轉換為 t [1…j-1]，那么我們就可以將s[i]轉換為 t[j]，使得滿足s[1..i] == t[1..j]，這樣總共也需要k+1個操作。（這里加上cost，是因為如果s[i]剛好等於t[j]，那么就不需要再做替換操作，即可滿足，如果不等，則需要再做一次替換操作，那么就需要k+1次操作）
因為我們要取得最小操作的個數，所以我們最后還需要將這三種情況的操作個數進行比較，取最小值作為d[i,j]的值；
d、然后重復執行3,4,5,6，最后的結果就在d[n,m]中；
圖解：
圖解過程如下：
step 1：初始化如下矩陣
step 2：從源串的第一個字符（“j”）開始，從上至下與目標串進行對比
如果兩個字符相等，則在從此位置的左，上，左上三個位置中取出最小的值；若不等，則在從此位置的左，上，左上三個位置中取出最小的值再加上1；
第一次，源串第一個字符“j” 與目標串的“j”對比,左，上，左上三個位置中取出最小的值0，因為兩字符相等，所以加上0；接着，依次對比“j”→“e”，“j”→“r”，“j”→“r”，，“j”→“y” 到掃描完目標串。
step 3：遍歷整個源串與目標串對比：
step 4：掃描完最后一列，則最后一個為最短編輯距離：
求出編輯距離，那么兩個字符串的相似度 Similarity = (Max(x,y) - Levenshtein)/Max(x,y)，其中 x,y 為源串和目標串的長度。
核心代碼如下：
public class LevenshteinDistance
{
private static LevenshteinDistance _instance = null;
public static LevenshteinDistance Instance
{
get
{
if (_instance == null)
{
return new LevenshteinDistance();
}
return _instance;
}
}
public int LowerOfThree(int first, int second, int third)
{
int min = first;
if (second < min)
min = second;
if (third < min)
min = third;
return min;
}
public int Compare_Distance(string str1, string str2)
{
int[,] Matrix;
int n = str1.Length;
int m = str2.Length;
int temp = 0;
char ch1;
char ch2;
int i = 0;
int j = 0;
if (n == 0)
{
return m;
}
if (m == 0)
{
return n;
}
Matrix = new int[n + 1, m + 1];
for (i = 0; i <= n; i++)
{
Matrix[i, 0] = i;
}
for (j = 0; j <= m; j++)
{
Matrix[0, j] = j;
}
for (i = 1; i <= n; i++)
{
ch1 = str1[i - 1];
for (j = 1; j <= m; j++)
{
ch2 = str2[j - 1];
if (ch1.Equals(ch2))
{
temp = 0;
}
else
{
temp = 1;
}
Matrix[i, j] = LowerOfThree(Matrix[i - 1, j] + 1, Matrix[i, j - 1] + 1, Matrix[i - 1, j - 1] + temp);
}
}
return Matrix[n, m];
}
public decimal LevenshteinDistancePercent(string str1, string str2)
{
int maxLenth = str1.Length > str2.Length ? str1.Length : str2.Length;
int val = Compare_Distance(str1, str2);
return 1 - (decimal)val / maxLenth;
}
}