Tries data structures

What is a TRIE?
• Tree based data structure used for
Information ReTRIEval task
• Also called as Digital Tree, Prefix tree, Radix
Tree
• Trie is used mostly for storing strings in
a compact way. E.g. words in dictionary
• A tries supports pattern matching queries in
time proportional to the pattern size

Trie – An ordered Tree
• S= { bear, bell, bid, bull, buy, sell, stock, stop}

Tries 4
Standard Tries
• The standard trie for a set of strings S is an ordered tree such that:
– Each node but the root is labeled with a character
– The children of a node are alphabetically ordered
– The paths from the external nodes to the root yield the strings of
S
• Example: standard trie for the set of strings
S = { bear, bell, bid, bull, buy, sell, stock, stop }
a
e
b
r
l
l
s
u
l
l
y
e t
l
l
o
c
k
p
i
d

TRIE Representation
struct Trie
{
struct Trie* S[26]; //a-z or A-Z
bool isEndOfWord;
};

Bill | 271-16-3624
Kathy | 278-49-1515

8
Applications of Tries
• A standard trie supports the following operations on a
preprocessed text in time O(m), where m = |X|
-word matching:
find the first occurrence of word X in the text
-prefix matching:
find the first occurrence of the longest prefix of word X in
the text
• Each operation is performed by tracing a path in the trie starting
at the root

Tries 9
Word Matching with a Trie
• We insert the
words of the
text into a trie
• Each leaf
stores the
occurrences of
the associated
word in the
text
s e e b e a r ? s e l l s t o c k !
s e e b u l l ? b u y s t o c k !
b i d s t o c k !
a
a
h e t h e b e l l ? s t o p !
b i d s t o c k !
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23
24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46
47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68
69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86
a r
87 88
a
e
b
l
s
u
l
e t
e
0, 24
o
c
i
l
r
6
l
78
d
47, 58
l
30
y
36
l
12
k
17, 40,
51, 62
p
84
h
e
r
69
a

Prefix : What is prefix:
• The prefix of a string is nothing but
any n letters n≤|S| that can be considered
beginning strictly from the starting of a string.
• For example , the word “abacaba” has the
following prefixes:
a
ab
aba
abac
abaca
abacab

Suffix
• The suffix of a string is nothing but
any n letters n≤|S| that can be considered ending
strictly at the end of a string.
• For example , the word “abacaba” has the
following prefixes:
a
ba
aba
caba
acaba
bacaba

Operations
• Insert – top-down traversal
• Delete – bottom-up
• Search – top-down

Tries 17
Analysis of Standard Tries
• A standard trie uses O(n) space and supports searches,
insertions and deletions in time O(dm), where:
n total size of the strings in S
m size of the string parameter of the operation
d size of the alphabet
a
e
b
r
l
l
s
u
l
l
y
e t
l
l
o
c
k
p
i
d

Insert Word into TRIE
Insert “their”

Pseudo code for Insertion of a string into a
TRIE
void insert(String s)
{
for(every char in string s)
{
if(child node belonging to current char is null)
{
child node=new Node();
}
current_node=child_node;
}
}

Search
• To search a trie for an element with a given
key,
– we start at the root and follow a path down the
trie until we either fall off the trie (i.e., we follow
a null pointer in a branch node)
or
– we reach an element node; The path we follow is
determined by the alphabets/digits of the search
key.

Pseudo code to check whether a single word
exists in a TRIE
boolean check(String s)
{
for(every char in String s)
{
if(child node of current char is null)
{
return false;
}
}
return true;
}

Check node has any children, before
deleting that node
//Node T has children or not
boolean haveChildren(struct Trie * T)
{
for(every child node of T)
{
if(child node belonging to current char is not null)
{
return True;
}
}
return False;
}

Algorithm requirements for deleting key 'k':
1. If key 'k' is not present in trie, then just return.
2. If key 'k' is not a prefix nor a suffix of any other key and
nodes of key 'k' are not part of any other key then all the
nodes starting from root node(excluding root node) to leaf
node of key 'k' should be deleted.
Delete key
“word”

Algorithm requirements for deleting key 'k': contd…
3. If key 'k' is a prefix of some other key, then leaf node
corresponding to key 'k' should be marked as 'not a leaf node'.
No node should be deleted in this case.
delete key - "xyz", then
without deleting any
node we have to simply
mark node 'z' as 'not a
leaf node' and change its
value to "NON_VALUE"

4. If key 'k' is a suffix of some other key 'k1', then all nodes of
key 'k' which are not part of key 'k1' should be deleted.
delete key - "xyzb", then we should only delete node
"b" of key "xyzb" since other nodes of this key are also
part of key "xyz".

Algorithm requirements for deleting key 'k': (contd..)
5. If key 'k' is not a prefix nor a suffix of any other key but
some nodes of key 'k' are shared with some other key 'k1',
then nodes of key 'k' which are not common to any other key
should be deleted and shared nodes should be kept intact.
delete key "abc" which
shares node 'a', node 'b'
with key "abb", then the
algorithm should delete
only node 'c' of key "abc"
and should not delete
node 'a' and node 'b'.

31
Compressed Tries
• Trie with nodes of degree at least 2
• Obtained from standard trie by compressing chains of redundant
nodes
Compressed Trie:
Standard Trie:

Tries 32
Compressed Tries
e
b
ar ll
s
u
ll y
ell to
ck p
id
a
e
b
r
l
l
s
u
l
l
y
e t
l
l
o
c
k
p
i
d

Draw a compressed Trie for
S= {romane, romanus, romulus, rubens, ruber, rubicon,
rubicundus}

Tries 35
Suffix Trie
• The suffix trie of a string X is the compressed trie of all the
suffixes of X ( i.e. the one defined over a set of
substrings of a string X )
e nimize
nimize ze
zei mi
mize nimize ze
m i n i z em i
0 1 2 3 4 5 6 7

Tries data structures

More Related Content

What's hot (20)

Similar to Tries data structures (20)

Recently uploaded (20)

Tries data structures