This document summarizes and compares several string matching algorithms: the Naive Shifting Algorithm, Rabin-Karp Algorithm, Finite Automaton String Matching, and Knuth-Morris-Pratt (KMP) Algorithm. It provides high-level descriptions of each algorithm, including their time complexities, which range from O(n*m) for the Naive algorithm to O(n) for the Rabin-Karp, Finite Automaton, and KMP algorithms. It also includes examples and pseudocode to illustrate how some of the algorithms work.

1. String
Matching
Algorithms
Mahdi Esmail oghli
m.esmailoghli@aut.ac.ir
Dr. Bagheri
Summer 2015
Amirkabir University of
Technology

2. ”Little String“
The Pattern
”Big String“
The Text
W
here
is
it?

3. For Example
Pattern: “CO”
Text: “COCACOLA”
Finding
Pattern
in
Text
Position: 0 1 2 3 4 5 6 7 8
Output: 1 5

4. Applications
• Searching Systems
•Genetic (BLAST)

5. String Matching Algorithms
NAIVE Shifting Algorithm
Robin - Karp Algorithm
Finite Automaton String Matching
Knuth - Morris - Pratt Algorithm

6. “Naive Shifting Algorithm”

7. NAIVE Shifting Algorithm
NAIVE-String-Macher(T,P)
1 n = T.length
2 m = P.length
3 for s = 0 to n-m
4 if p[1..m] == T[s+1 .. s+m]
5 print “Pattern occurs with shift” s

8. Order of
“NAIVE Shifting Algorithm”
O (( n-m+1 ) * m )
It is not very good matching algorithm

9. NAIVE Shifting Algorithm
“CO”
“COCACOLA”
Yes Yes

10. “Text”
“Text”

11. Text:
CWERUFIVNWQERUQONACRUIRIUQVWCNTQOMXRHQG
ERYCUGOFRUWFEQWUFYWOAMFIHAUFIHFGERGOUD
CJNWUVNWIVNCKMXOQIJXWOEUHFNWCVKAMSCWDIVN
WUEBVFNQIONVOWNVWIUBVEIWLNCMIQWC9URBGUR
IPMOQUNBFUYIWBEIUONFMPOQAFMQIONSDFCOYQWB
CO

12. “The Rabin-Karp Algorithm”

13. The Rabin-Karp Algorithm
Rabin-Karp-Matcher(T, P, d, q)
1 n = T.length
2 m = P.length
3 h = d^(m-1) mod q
4 p = 0
5 t0 = 0
6 for i = 1 to m //PreProcessing
7 p = (dp + p[i]) mod q
8 t0 = (dt0 + T[i]) mod q
9 for s = 0 to n-m //Matching
10 if p == ts
11 if P[1..m] == T[s+1..s+m]
12 print “Pattern occurs with shift” s
13 if s < n-m
14 ts+1 = (d(ts - T[s + 1]h) + T[s + m + 1]) mod 1

14. 2 3 5 9 0 2 3 1 4 1 5 2 6 7 3 9 9 2 1
mod 13
7
2 3 5 9 0 2 3 1 4 1 5 2 6 7 3 9 9 2 1
8 9 3 11 0 1 7 8 4 5 10 11 7 9 11
Pattern 3 1 4 1 5 7
mod 13
… …

15. “ String Matching With Finite Automata "

16. Finite Automaton String Matching
Many String-Matching algorithms build a finite
automaton
Because they are efficient:
They examine each text character EXACTLY ONCE
constant time for each character

17. Finite Automaton String Matching
O ( n )
After preprocessing the pattern to build the automaton

18. Construct string matching Automaton
Pattern: ababaca
a a
a
a
a
a
aab b
b
b
c
320 1 654 7
i - 1 2 3 4 5 6 7 8 9 10 11
T[i] - a b a b a b a c a b a
State 0 1 2 3 4 5 4 5 6 7 2 3

19. Finite Automaton Matcher
Finite-Automaton-Matcher(T, 𝝈, m)
1 n = T.length
2 q = 0
3 for i=0 to n
4 q = 𝝈 (q, T[i])
5 if q == m
6 print ”Pattern occurs with shift” i-m

20. “The Knuth Moris Pratt Algorithm”
(KMP Algorithm)
• Linear-Time String-Matching Algorithm

21. KMP Algorithm
2 Stage:
• Prefix Function
• String Matching

22. Compute-Prefix-Function
Compute-Prefix-Function(P)
1 m = P.length
2 let π[1..m] be a new array
3 π[1] = 0
4 k = 0
5 for q = 2 to m
6 while k > 0 and P[k + 1] ≠ P[q]
7 k = π[k]
8 if P[k + 1] == P[q]
9 k = k + 1
10 π[q] = k
11 return π

23. Compute-Prefix-Function
i 1 2 3 4 5 6 7
P[i] a b a b a c a
π[i] 0 0 1 2 3 0 1

24. KMP Algorithm
KMP-Macher(T, P)
1 n = T.length
2 m = P.length
3 π = Compute-Prefix-Function(P)
4 q = 0 //number of characters matched
5 for i = 0 to n //scan the text from left to right
6 while q > 0 and P[q + 1] ≠ T[i]
7 q = π[q] //next character does not match
8 if P[q + 1] == T[i]
9 q = q + 1 //next character matches
10 if q == m //is all of P matched
11 print ” Pattern occurs with shift ” i-m
12 q = π[q] //look for the next match

25. KMP Algorithm
O ( n )
Where N is length of text

26. Thank You