C#实现的字符串相似度对比类

这篇文章主要介绍了C#实现的字符串相似度对比类,本文直接给出类实现代码,代码中包含详细注释,需要的朋友可以参考下

本类适用于比较2个字符的相似度，代码如下：

1. using System; 
2. using System.Collections.Generic; 
3. using System.Text; 
4.  
5. public class StringCompute 
6. { 
7. #region 私有变量 
8. /// <summary> 
9. /// 字符串1 
10. /// </summary> 
11. private char[] _ArrChar1; 
12. /// <summary> 
13. /// 字符串2 
14. /// </summary> 
15. private char[] _ArrChar2; 
16. /// <summary> 
17. /// 统计结果 
18. /// </summary> 
19. private Result _Result; 
20. /// <summary> 
21. /// 开始时间 
22. /// </summary> 
23. private DateTime _BeginTime; 
24. /// <summary> 
25. /// 结束时间 
26. /// </summary> 
27. private DateTime _EndTime; 
28. /// <summary> 
29. /// 计算次数 
30. /// </summary> 
31. private int _ComputeTimes; 
32. /// <summary> 
33. /// 算法矩阵 
34. /// </summary> 
35. private int[,] _Matrix; 
36. /// <summary> 
37. /// 矩阵列数 
38. /// </summary> 
39. private int _Column; 
40. /// <summary> 
41. /// 矩阵行数 
42. /// </summary> 
43. private int _Row; 
44. #endregion 
45. #region 属性 
46. public Result ComputeResult 
47. { 
48. get { return _Result; } 
49. } 
50. #endregion 
51. #region 构造函数 
52. public StringCompute(string str1, string str2) 
53. { 
54. this.StringComputeInit(str1, str2); 
55. } 
56. public StringCompute() 
57. { 
58. } 
59. #endregion 
60. #region 算法实现 
61. /// <summary> 
62. /// 初始化算法基本信息 
63. /// </summary> 
64. /// <param name="str1">字符串1</param> 
65. /// <param name="str2">字符串2</param> 
66. private void StringComputeInit(string str1, string str2) 
67. { 
68. _ArrChar1 = str1.ToCharArray(); 
69. _ArrChar2 = str2.ToCharArray(); 
70. _Result = new Result(); 
71. _ComputeTimes = 0; 
72. _Row = _ArrChar1.Length + 1; 
73. _Column = _ArrChar2.Length + 1; 
74. _Matrix = new int[_Row, _Column]; 
75. } 
76. /// <summary> 
77. /// 计算相似度 
78. /// </summary> 
79. public void Compute() 
80. { 
81. //开始时间 
82. _BeginTime = DateTime.Now; 
83. //初始化矩阵的第一行和第一列 
84. this.InitMatrix(); 
85. int intCost = 0; 
86. for (int i = 1; i < _Row; i++) 
87. { 
88. for (int j = 1; j < _Column; j++) 
89. { 
90. if (_ArrChar1[i - 1] == _ArrChar2[j - 1]) 
91. { 
92. intCost = 0; 
93. } 
94. else 
95. { 
96. intCost = 1; 
97. } 
98. //关键步骤，计算当前位置值为左边+1、上面+1、左上角+intCost中的最小值  
99. //循环遍历到最后_Matrix[_Row - 1, _Column - 1]即为两个字符串的距离 
100. _Matrix[i, j] = this.Minimum(_Matrix[i - 1, j] + 1, _Matrix[i, j - 1] + 1, _Matrix[i - 1, j - 1] + intCost); 
101. _ComputeTimes++; 
102. } 
103. } 
104. //结束时间 
105. _EndTime = DateTime.Now; 
106. //相似率 移动次数小于最长的字符串长度的20%算同一题 
107. int intLength = _Row > _Column ? _Row : _Column; 
108.  
109. _Result.Rate = (1 - (decimal)_Matrix[_Row - 1, _Column - 1] / intLength); 
110. _Result.UseTime = (_EndTime - _BeginTime).ToString(); 
111. _Result.ComputeTimes = _ComputeTimes.ToString(); 
112. _Result.Difference = _Matrix[_Row - 1, _Column - 1]; 
113. } 
114.  
115.  
116. /// <summary> 
117. /// 计算相似度（不记录比较时间） 
118. /// </summary> 
119. public void SpeedyCompute() 
120. { 
121. //开始时间 
122. //_BeginTime = DateTime.Now; 
123. //初始化矩阵的第一行和第一列 
124. this.InitMatrix(); 
125. int intCost = 0; 
126. for (int i = 1; i < _Row; i++) 
127. { 
128. for (int j = 1; j < _Column; j++) 
129. { 
130. if (_ArrChar1[i - 1] == _ArrChar2[j - 1]) 
131. { 
132. intCost = 0; 
133. } 
134. else 
135. { 
136. intCost = 1; 
137. } 
138. //关键步骤，计算当前位置值为左边+1、上面+1、左上角+intCost中的最小值  
139. //循环遍历到最后_Matrix[_Row - 1, _Column - 1]即为两个字符串的距离 
140. _Matrix[i, j] = this.Minimum(_Matrix[i - 1, j] + 1, _Matrix[i, j - 1] + 1, _Matrix[i - 1, j - 1] + intCost); 
141. _ComputeTimes++; 
142. } 
143. } 
144. //结束时间 
145. //_EndTime = DateTime.Now; 
146. //相似率 移动次数小于最长的字符串长度的20%算同一题 
147. int intLength = _Row > _Column ? _Row : _Column; 
148.  
149. _Result.Rate = (1 - (decimal)_Matrix[_Row - 1, _Column - 1] / intLength); 
150. // _Result.UseTime = (_EndTime - _BeginTime).ToString(); 
151. _Result.ComputeTimes = _ComputeTimes.ToString(); 
152. _Result.Difference = _Matrix[_Row - 1, _Column - 1]; 
153. } 
154. /// <summary> 
155. /// 计算相似度 
156. /// </summary> 
157. /// <param name="str1">字符串1</param> 
158. /// <param name="str2">字符串2</param> 
159. public void Compute(string str1, string str2) 
160. { 
161. this.StringComputeInit(str1, str2); 
162. this.Compute(); 
163. } 
164.  
165. /// <summary> 
166. /// 计算相似度 
167. /// </summary> 
168. /// <param name="str1">字符串1</param> 
169. /// <param name="str2">字符串2</param> 
170. public void SpeedyCompute(string str1, string str2) 
171. { 
172. this.StringComputeInit(str1, str2); 
173. this.SpeedyCompute(); 
174. } 
175. /// <summary> 
176. /// 初始化矩阵的第一行和第一列 
177. /// </summary> 
178. private void InitMatrix() 
179. { 
180. for (int i = 0; i < _Column; i++) 
181. { 
182. _Matrix[0, i] = i; 
183. } 
184. for (int i = 0; i < _Row; i++) 
185. { 
186. _Matrix[i, 0] = i; 
187. } 
188. } 
189. /// <summary> 
190. /// 取三个数中的最小值 
191. /// </summary> 
192. /// <param name="First"></param> 
193. /// <param name="Second"></param> 
194. /// <param name="Third"></param> 
195. /// <returns></returns> 
196. private int Minimum(int First, int Second, int Third) 
197. { 
198. int intMin = First; 
199. if (Second < intMin) 
200. { 
201. intMin = Second; 
202. } 
203. if (Third < intMin) 
204. { 
205. intMin = Third; 
206. } 
207. return intMin; 
208. } 
209. #endregion 
210. } 
211. /// <summary> 
212. /// 计算结果 
213. /// </summary> 
214. public struct Result 
215. { 
216. /// <summary> 
217. /// 相似度 
218. /// </summary> 
219. public decimal Rate; 
220. /// <summary> 
221. /// 对比次数 
222. /// </summary> 
223. public string ComputeTimes; 
224. /// <summary> 
225. /// 使用时间 
226. /// </summary> 
227. public string UseTime; 
228. /// <summary> 
229. /// 差异 
230. /// </summary> 
231. public int Difference; 
232. } 

调用方法：

1. // 方式一 
2. StringCompute stringcompute1 = new StringCompute(); 
3. stringcompute1.SpeedyCompute("对比字符一", "对比字符二"); // 计算相似度， 不记录比较时间 
4. decimal rate = stringcompute1.ComputeResult.Rate; // 相似度百分之几，完全匹配相似度为1 
5.  
6. // 方式二 
7. StringCompute stringcompute2 = new StringCompute(); 
8. stringcompute2.Compute(); // 计算相似度， 记录比较时间 
9. string usetime = stringcompute2.ComputeResult.UseTime; // 对比使用时间