一个字符串搜索的Aho-Corasick算法

Aho和Corasick对KMP算法(Knuth–Morris–Pratt algorithm)进行了改进，Aho-Corasick算法(Aho-Corasick algorithm)利用构建树，总时间复杂度是O(n)。原理图如下(摘自Aho-Corasick string matching in C#)：

Building of the keyword tree (figure 1 - after the first step, figure 2 - tree with the fail function)

C#版本的实现代码可以从Aho-Corasick string matching in C#得到，也可以点击这里获得该算法的PDF文档。

这是一个应用示例：

它能将载入的RTF文档中的搜索关键字高亮，检索速度较快，示例没有实现全字匹配，算法代码简要如下：

1. /* Aho-Corasick text search algorithm implementation
2. *
3. * For more information visit
4. *      - http://www.cs.uku.fi/~kilpelai/BSA05/lectures/slides04.pdf
5. */
6. using System;
7. using System.Collections;
8. namespace EeekSoft.Text
9. {
10. /// <summary>
11. /// Interface containing all methods to be implemented
12. /// by string search algorithm
13. /// </summary>
14. public interface IStringSearchAlgorithm
15. {
16. #region Methods & Properties
17. /// <summary>
18. /// Ignore case of letters
19. /// </summary>
20. bool IgnoreCase { get; set; }
21. /// <summary>
22. /// List of keywords to search for
23. /// </summary>
24. string[] Keywords { get; set; }
25. /// <summary>
26. /// Searches passed text and returns all occurrences of any keyword
27. /// </summary>
28. /// <param name="text">Text to search</param>
29. /// <returns>Array of occurrences</returns>
30. StringSearchResult[] FindAll(string text);
31. /// <summary>
32. /// Searches passed text and returns first occurrence of any keyword
33. /// </summary>
34. /// <param name="text">Text to search</param>
35. /// <returns>First occurrence of any keyword (or StringSearchResult.Empty if text doesn't contain any keyword)</returns>
36. StringSearchResult FindFirst(string text);
37. /// <summary>
38. /// Searches passed text and returns true if text contains any keyword
39. /// </summary>
40. /// <param name="text">Text to search</param>
41. /// <returns>True when text contains any keyword</returns>
42. bool ContainsAny(string text);
43. #endregion
44. }
45. /// <summary>
46. /// Structure containing results of search
47. /// (keyword and position in original text)
48. /// </summary>
49. public struct StringSearchResult
50. {
51. #region Members
52. private int _index;
53. private string _keyword;
54. /// <summary>
55. /// Initialize string search result
56. /// </summary>
57. /// <param name="index">Index in text</param>
58. /// <param name="keyword">Found keyword</param>
59. public StringSearchResult(int index, string keyword)
60. {
61. _index = index; _keyword = keyword;
62. }
63. /// <summary>
64. /// Returns index of found keyword in original text
65. /// </summary>
66. public int Index
67. {
68. get { return _index; }
69. }
70. /// <summary>
71. /// Returns keyword found by this result
72. /// </summary>
73. public string Keyword
74. {
75. get { return _keyword; }
76. }
77. /// <summary>
78. /// Returns empty search result
79. /// </summary>
80. public static StringSearchResult Empty
81. {
82. get { return new StringSearchResult(-1, ""); }
83. }
84. #endregion
85. }
86. /// <summary>
87. /// Class for searching string for one or multiple
88. /// keywords using efficient Aho-Corasick search algorithm
89. /// </summary>
90. public class StringSearch : IStringSearchAlgorithm
91. {
92. #region Objects
93. /// <summary>
94. /// Tree node representing character and its
95. /// transition and failure function
96. /// </summary>
97. class TreeNode
98. {
99. #region Constructor & Methods
100. /// <summary>
101. /// Initialize tree node with specified character
102. /// </summary>
103. /// <param name="parent">Parent node</param>
104. /// <param name="c">Character</param>
105. public TreeNode(TreeNode parent, char c)
106. {
107. _char = c; _parent = parent;
108. _results = new ArrayList();
109. _resultsAr = new string[] { };
110. _transitionsAr = new TreeNode[] { };
111. _transHash = new Hashtable();
112. }
113. /// <summary>
114. /// Adds pattern ending in this node
115. /// </summary>
116. /// <param name="result">Pattern</param>
117. public void AddResult(string result)
118. {
119. if (_results.Contains(result)) return;
120. _results.Add(result);
121. _resultsAr = (string[])_results.ToArray(typeof(string));
122. }
123. /// <summary>
124. /// Adds trabsition node
125. /// </summary>
126. /// <param name="node">Node</param>
127. //public void AddTransition(TreeNode node)
128. //{
129. //    AddTransition(node, false);
130. //}
131. /// <summary>
132. /// Adds trabsition node
133. /// </summary>
134. /// <param name="node">Node</param>
135. /// <param name="ignoreCase">Ignore case of letters</param>
136. public void AddTransition(TreeNode node, bool ignoreCase)
137. {
138. if (ignoreCase) _transHash.Add(char.ToLower(node.Char), node);
139. else _transHash.Add(node.Char, node);
140. TreeNode[] ar = new TreeNode[_transHash.Values.Count];
141. _transHash.Values.CopyTo(ar, 0);
142. _transitionsAr = ar;
143. }
144. /// <summary>
145. /// Returns transition to specified character (if exists)
146. /// </summary>
147. /// <param name="c">Character</param>
148. /// <param name="ignoreCase">Ignore case of letters</param>
149. /// <returns>Returns TreeNode or null</returns>
150. public TreeNode GetTransition(char c, bool ignoreCase)
151. {
152. if (ignoreCase)
153. return (TreeNode)_transHash[char.ToLower(c)];
154. return (TreeNode)_transHash[c];
155. }
156. /// <summary>
157. /// Returns true if node contains transition to specified character
158. /// </summary>
159. /// <param name="c">Character</param>
160. /// <param name="ignoreCase">Ignore case of letters</param>
161. /// <returns>True if transition exists</returns>
162. public bool ContainsTransition(char c, bool ignoreCase)
163. {
164. return GetTransition(c, ignoreCase) != null;
165. }
166. #endregion
167. #region Properties
168. private char _char;
169. private TreeNode _parent;
170. private TreeNode _failure;
171. private ArrayList _results;
172. private TreeNode[] _transitionsAr;
173. private string[] _resultsAr;
174. private Hashtable _transHash;
175. /// <summary>
176. /// Character
177. /// </summary>
178. public char Char
179. {
180. get { return _char; }
181. }
182. /// <summary>
183. /// Parent tree node
184. /// </summary>
185. public TreeNode Parent
186. {
187. get { return _parent; }
188. }
189. /// <summary>
190. /// Failure function - descendant node
191. /// </summary>
192. public TreeNode Failure
193. {
194. get { return _failure; }
195. set { _failure = value; }
196. }
197. /// <summary>
198. /// Transition function - list of descendant nodes
199. /// </summary>
200. public TreeNode[] Transitions
201. {
202. get { return _transitionsAr; }
203. }
204. /// <summary>
205. /// Returns list of patterns ending by this letter
206. /// </summary>
207. public string[] Results
208. {
209. get { return _resultsAr; }
210. }
211. #endregion
212. }
213. #endregion
214. #region Local fields
215. /// <summary>
216. /// Root of keyword tree
217. /// </summary>
218. private TreeNode _root;
219. /// <summary>
220. /// Keywords to search for
221. /// </summary>
222. private string[] _keywords;
223. #endregion
224. #region Initialization
225. /// <summary>
226. /// Initialize search algorithm (Build keyword tree)
227. /// </summary>
228. /// <param name="keywords">Keywords to search for</param>
229. /// <param name="ignoreCase">Ignore case of letters (the default is false)</param>
230. public StringSearch(string[] keywords, bool ignoreCase)
231. : this(keywords)
232. {
233. IgnoreCase = ignoreCase;
234. }
235. /// <summary>
236. /// Initialize search algorithm (Build keyword tree)
237. /// </summary>
238. /// <param name="keywords">Keywords to search for</param>
239. public StringSearch(string[] keywords)
240. {
241. Keywords = keywords;
242. }
243. /// <summary>
244. /// Initialize search algorithm with no keywords
245. /// (Use Keywords property)
246. /// </summary>
247. public StringSearch()
248. { }
249. #endregion
250. #region Implementation
251. /// <summary>
252. /// Build tree from specified keywords
253. /// </summary>
254. void BuildTree()
255. {
256. // Build keyword tree and transition function
257. _root = new TreeNode(null, ' ');
258. foreach (string p in _keywords)
259. {
260. // add pattern to tree
261. TreeNode nd = _root;
262. foreach (char c in p)
263. {
264. TreeNode ndNew = null;
265. foreach (TreeNode trans in nd.Transitions)
266. {
267. if (this.IgnoreCase)
268. {
269. if (char.ToLower(trans.Char) == char.ToLower(c)) { ndNew = trans; break; }
270. }
271. else
272. {
273. if (trans.Char == c) { ndNew = trans; break; }
274. }
275. }
276. if (ndNew == null)
277. {
278. ndNew = new TreeNode(nd, c);
279. nd.AddTransition(ndNew, this.IgnoreCase);
280. }
281. nd = ndNew;
282. }
283. nd.AddResult(p);
284. }
285. // Find failure functions
286. ArrayList nodes = new ArrayList();
287. // level 1 nodes - fail to root node
288. foreach (TreeNode nd in _root.Transitions)
289. {
290. nd.Failure = _root;
291. foreach (TreeNode trans in nd.Transitions) nodes.Add(trans);
292. }
293. // other nodes - using BFS
294. while (nodes.Count != 0)
295. {
296. ArrayList newNodes = new ArrayList();
297. foreach (TreeNode nd in nodes)
298. {
299. TreeNode r = nd.Parent.Failure;
300. char c = nd.Char;
301. while (r != null && !r.ContainsTransition(c, this.IgnoreCase)) r = r.Failure;
302. if (r == null)
303. nd.Failure = _root;
304. else
305. {
306. nd.Failure = r.GetTransition(c, this.IgnoreCase);
307. foreach (string result in nd.Failure.Results)
308. nd.AddResult(result);
309. }
310. // add child nodes to BFS list
311. foreach (TreeNode child in nd.Transitions)
312. newNodes.Add(child);
313. }
314. nodes = newNodes;
315. }
316. _root.Failure = _root;
317. }
318. #endregion
319. #region Methods & Properties
320. /// <summary>
321. /// Ignore case of letters
322. /// </summary>
323. public bool IgnoreCase
324. {
325. get;
326. set;
327. }
328. /// <summary>
329. /// Keywords to search for (setting this property is slow, because
330. /// it requieres rebuilding of keyword tree)
331. /// </summary>
332. public string[] Keywords
333. {
334. get { return _keywords; }
335. set
336. {
337. _keywords = value;
338. BuildTree();
339. }
340. }
341. /// <summary>
342. /// Searches passed text and returns all occurrences of any keyword
343. /// </summary>
344. /// <param name="text">Text to search</param>
345. /// <returns>Array of occurrences</returns>
346. public StringSearchResult[] FindAll(string text)
347. {
348. ArrayList ret = new ArrayList();
349. TreeNode ptr = _root;
350. int index = 0;
351. while (index < text.Length)
352. {
353. TreeNode trans = null;
354. while (trans == null)
355. {
356. trans = ptr.GetTransition(text[index], this.IgnoreCase);
357. if (ptr == _root) break;
358. if (trans == null) ptr = ptr.Failure;
359. }
360. if (trans != null) ptr = trans;
361. foreach (string found in ptr.Results)
362. ret.Add(new StringSearchResult(index - found.Length + 1, found));
363. index++;
364. }
365. return (StringSearchResult[])ret.ToArray(typeof(StringSearchResult));
366. }
367. /// <summary>
368. /// Searches passed text and returns first occurrence of any keyword
369. /// </summary>
370. /// <param name="text">Text to search</param>
371. /// <returns>First occurrence of any keyword (or StringSearchResult.Empty if text doesn't contain any keyword)</returns>
372. public StringSearchResult FindFirst(string text)
373. {
374. ArrayList ret = new ArrayList();
375. TreeNode ptr = _root;
376. int index = 0;
377. while (index < text.Length)
378. {
379. TreeNode trans = null;
380. while (trans == null)
381. {
382. trans = ptr.GetTransition(text[index], this.IgnoreCase);
383. if (ptr == _root) break;
384. if (trans == null) ptr = ptr.Failure;
385. }
386. if (trans != null) ptr = trans;
387. foreach (string found in ptr.Results)
388. return new StringSearchResult(index - found.Length + 1, found);
389. index++;
390. }
391. return StringSearchResult.Empty;
392. }
393. /// <summary>
394. /// Searches passed text and returns true if text contains any keyword
395. /// </summary>
396. /// <param name="text">Text to search</param>
397. /// <returns>True when text contains any keyword</returns>
398. public bool ContainsAny(string text)
399. {
400. TreeNode ptr = _root;
401. int index = 0;
402. while (index < text.Length)
403. {
404. TreeNode trans = null;
405. while (trans == null)
406. {
407. trans = ptr.GetTransition(text[index], this.IgnoreCase);
408. if (ptr == _root) break;
409. if (trans == null) ptr = ptr.Failure;
410. }
411. if (trans != null) ptr = trans;
412. if (ptr.Results.Length > 0) return true;
413. index++;
414. }
415. return false;
416. }
417. #endregion
418. }
419. }

示例下载页面：http://www.uushare.com/user/m2nlight/file/2722093