Representing Patterns: Regular

Expressions
Patterns can be represented by just using two
special characters:


“ ” represents alternatives.


ab cd matches ab or cd.
Data Structures and Algorithms II 

(a bc)d matches ad or bcd.

Lecture 10:
Pattern Matching Algorithms


“*” allows repetition (0 or more times).

ab* matches a, ab, abb, abbb etc.
Motivation a(bc)* matches a, abc, abcbc, etc.

Representing Patterns Brackets may be used, as illustrate above. * has



higher priority than . Simple concatenation has

A Simple Pattern Matching Algorithm.


priority in between, so a bc means (a or (b followed

by c)) but ab* means (a followed by (b*)).
Further characters are often used for conciseness:


“?” matches any character at all.

a?b matches aab abb azb..


“+” allows 1 or more repetitions.

ab+ matches ab, abb, abbb etc.

1 3

Regular Expressions
Pattern Matching: Motivation Given the following regular expressions, which of
For many applications we want tools to find if given the example strings do you think it would match?
string matches some criteria, e.g.,


(c de)*


Find all filenames that end with .cpp 1. cd

Check whether word entered is yes, y, Yes, Y, 2. ccc

or variant. 3. cdede

Search for a line in a file containing both “data” 

(a*b c+) 

and “abstraction”.
1. b
These can typically be done by checking if strings 2. aaaa
match a pattern. 3. ccc
We need: 4. ab

A notation to describe these patterns.



?*(ie ei)?* 

An algorithm to check if a pattern matches a 1. ii

given string. 2. piece
3. sheik

2 4
 Regular Expressions and Finite State Implementing the Machine
Machines (FSMs) 

The finite state machine (FSM) suggests a good

way to represent patterns so that pattern


Can represent regular expressions in terms of a

matching algorithms can be easily
network of nodes and connections between
implemented.
them.


We could represent our FSM using a general



These nodes represent states, and the graph ADTs (discussed later). But we never
connections represent transitions between allow a node to have more than two neighbours,
them. so a simpler data structure is possible.
The nodes in our pattern matcher capture the
state “in which a certain character in the pattern


Each state has one or two successor states.. so

has been successfully matched”. use an Nx2 array where N is number of states,
and store in it the indices of successor states.


The network is referred to as a finite-state

machine (and has many applications in CS).


Also need array to store characters in nodes -

let content be “?” for choice nodes.


In particular, it is a non-deterministic finite

state machine, as it will need to have choice For the example FSM in earlier slide we’d have:
nodes. You won’t be able to immediately next[0][0]=1 ch[1]=’?’
determine which route to take in the network next[1][0]=2 ch[2]=’a’
just by traversing the string. next[1][1]=3 ch[3]=’b’
next[2][0]=5 etc.

5 7

Algorithm
We’re now ready for an algorithm for pattern
matching.
Example:
6 

We use need a data structure that allows us to

e
a keep track, as we go through the string, which
choice 2 7 8 characters are legal according to the pattern.
0 d
start 1 finish
5 choice


We use a special list structure for this - it

b c contains the possible states in the FSM
3 4
corresponding to the current and next character
(italicised bits are just for explanation or referring to it) in the string being analysed.
String matches if you can traverse network from 

This is updated as we simultaneously go

start to finish, matching all the characters in the through the FSM and move up in the string -
string. (e.g., bcdeee, ad). based on possible state corresponding to
current character in string, we can determine
from FSM possible states for next character in
string.

6 8
 Pattern Matching Algorithm
(j=position in string)
dq.put(’+’); j=0;
state=next[start][0];

A variant of the stack/queue is used as the While not at end of string or pattern.
ADT: double ended queue allows nodes to be 

If (state==’+’) j++; 

put on front or end of queue: dq.put adds items

dq.put(’+’);

to end, while dq.push adds items to start.

(finished dealing with char j so move on..)

Split the queue in two halves with special 

else if (ch[state]==str[j])
character
dq.put(next[state][0])
e.g., (1 2 + 5 6)
(char matches one in pattern, so put next state
States before “+” represent possible states
on queue).
corresponding to current character.
States after “+” represent possible states


else if (ch[state]=’?’)
corresponding to next character. dq.push(next[state][0]);
dq.push(next[state][1]);

(choice node so put alternatives on front of

queue.)


state=dq.pop();
(remove state from dq)

9 11

Outline of Algorithm Example

Main step in algorithm is: Suppose:
next[0][0]=1 ch[1]=? str=’’abd’’

Look at current character, and possible current

next[1][0]=2 ch[2]=a
state in FSM.
next[1][1]=4 ch[3]=b

If the state in the FSM is a choice node, that next[2][0]=3 ch[4]=c

means the current character might correspond next[3][0]=5 ch[5]=d
to either of the choices - so put them on the next[4][0]=5 node 6 = finish
next[5][0]=6
queue as possibilities for current character.
Working through algorithm we have,

If the state in the FSM contains a character

dq j state
matching the current character, then the next
(+) 0 1
character should match the next state in the
(2 4 +) 0 1 (as ch[1]=’?’)
FSM - so put that next state on the (end of) the (4 +) 0 2 (after dq.pop)
queue (as possibility for next char). (4 + 3) 0 2 (as ch[2]=str[0])
e.g., (+ 3) 0 3 (after dq.pop)
(3) 0 + (after dq.pop)
queue = (1 +) str=’’ad’’ (3 +) 1 + (state=’+’)
1 is a choice node (+) 1 3 (after dq.pop)
queue = (2 3 +) (+ 5) 1 3 (ch[3]=str[1])
2 corresponds to ’a’ (5) 1 +
state 2 has successor 5 (5 +) 2 +
queue = (3 + 5) (+) 2 5

10 12
(+ 6) 2 5
(6) 2 +
(6 +) 3 +
(+) 3 6

.. and we’re at the end of the string and last state in

the pattern, so the match succeeds.

13

Summary


Regular expressions are equivalent to finite

state machines, where each state in the machine
represents a character.


One algorithm for pattern matching involves:

– Tranforming a regular expression into an

FSM, and representing this using arrays.
– Searching the network using a search
method which uses a double ended queue,
and divides it so we know which states
correspond to options for current character,
and which for the next character.
– This is a fairly simple and efficient
algorithm for a difficult problem. Efficiency
O(MN*N) where M = number of states; N
= length of string.

14