DATA STRUCTURE

TRIE

Name: Mahadi Hassan

ID: 1320133042
&
Name: Mahmud Rahman Parag
ID: 1320900042
 What Is TRIE?

Trie Is An Efficient Information Retrieval Data Structure Also Called

Digital Tree And Sometimes Radix Tree Or Prefix Tree (As They Can
Be Searched By Prefixes), Is An Ordered Tree Data Structure That Is
Used To Store A Dynamic Set Or Associative Array Where The Keys
Are Usually Strings.
 Why Trie Data Structure?

• Searching trees in general favor keys which are of fixed size

since this leads to efficient storage management.

• However in case of applications which are retrieval based and

which call for keys varying length, tries provide better options.

• Tries are also called as Lexicographic Search trees.

• The name trie (pronounced as “try”)originated from the word

“retrieval”.
 TYPES OF TRIE

1.Standard Tries
2.Compressed Tries
3.Suffix Tries
 STANDARD TRIE

The Standard Trie For A Set Of Strings S Is An Ordered Tree Such That:

Each Node Labeled With A Character (Without Root).

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 A Set Of Strings S

S = { bear, bell, bid, bull, buy, sell, stock, stop }

 TIME COMPLEXITY

A Standard Trie Uses O(n) Space. Operations (find, insert, remove) Take Time

O(dm) Each, Where:

n = Total Size Of The Strings In S,

m = Size Of The String Parameter Of The Operation

d = Alphabet Size
 TRIE SPECIFICATION
Operations:
addWord
Function Adds word to an .
Postcondition Trie is not full
searchWord
Function Search a word in the trie
Postcondition Returns true if the world is found and false otherwise.
deleteWord
Function Delete a word in the trie
Postcondition Trie is not empty
 TRIE SPECIFICATION
Operations:
print
Function Print the word in the trie
Postcondition Trie either maybe full or not
 NODE STRUCTURE

Class Node
{
public:
char value; The Character Value (A – Z) / (a – z).
bool end; Indicates Whether This Node Completes A Word
Node *children[26]; Represents The 26 Letters In The Alphabet
}
 NODE STRUCTURE

A Node Type
Character Boolean Pointer
Data Data Array

char value

bool end
1 1 1 1 1 1 1 1 1 1 2 2 2 2 2 2 \
0 1 2 3 4 5 6 7 8 9
0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 0
INSERTION
 INSERTION ALGORITHM
Insert: Apple

First Create A Root That Has Empty String And Every Single Pointer Array
Must Point To The NULL (Default). And Boolean Value Of Every Node Must Be
false By Default.

false
1 2 2
0 … … …
0 0 6

NULL
 INSERTION ALGORITHM
Insert: Apple
Root
 INSERTION ALGORITHM
Insert: Apple

Second Convert All Of The String’s Character To Uppercase Or To Lowercase.

char currentChar = tolower(word.at(i));

 INSERTION ALGORITHM
Insert: Apple

Second Convert All Of The String’s Character To Uppercase Or To Lowercase.

char currentChar = tolower(word.at(i));

Here, Suppose string s = “Apple” And Length Of String Is 5 So……….
 INSERTION ALGORITHM
Insert: Apple

Second Convert All Of The String’s Character To Uppercase Or To Lowercase.

char currentChar = tolower(word.at(i));

Here, Suppose string s = “Apple” And Length Of String Is 5 So……….
s[0] = A, s[1] = p, s[2] = p, s[3] = l, s[4] = e
 INSERTION ALGORITHM
Insert: Apple

Second Convert All Of The String’s Character To Uppercase Or To Lowercase.

char currentChar = tolower(word.at(i));

Here, Suppose string s = “Apple” And Length Of String Is 5 So……….
s[0] = A, s[1] = p, s[2] = p, s[3] = l, s[4] = e

A p p l e
0 1 2 3 4
 INSERTION ALGORITHM
Insert: Apple

A p p l e
0 1 2 3 4
 INSERTION ALGORITHM
Insert: Apple

A p p l e
0 1 2 3 4

char currentChar = tolower(word.at(0));

currentChar a
 INSERTION ALGORITHM
Insert: Apple

Then Get The Correct Index For The Appropriate Character

int index = currentChar - 'a';

So……….
currentChar a

int index = currentChar - 'a'; int index = a - 'a';

int index = 0;
 INSERTION ALGORITHM
Insert: Apple

Declare A Pointer Node Type Pointer Variable That Point To The Root

Node *currentNode = root;

currentNode Root
Pointing To
 INSERTION ALGORITHM
Insert: Apple
Root
currentNode
 INSERTION ALGORITHM
Insert: Apple
Check If The Current Node Has The Current Character As One Of Its
Descendants
if (currentNode->children[0] != NULL)
{
currentNode = currentNode->children[0];
}

false
1 2 2
0 … … … If 0 Pointing To The NULL?
0 0 6

NULL
 INSERTION ALGORITHM
Insert: Apple
Check If The Current Node Has The Current Character As One Of Its
Descendants
if (currentNode->children[0] != NULL)
{
currentNode = currentNode->children[0];
} Here 0 Is The Index Value ( a – ‘a’ )
Is 0 Pointing To The NULL?
false
1 2 2 YES!
0 … … …
0 0 6
So IF Statement Won’t Execute…………
And The Current Node Doesn't have the current
NULL
character as one of its descendants
 INSERTION ALGORITHM
Insert: Apple
So………. Node Constructor
else
{
Node *newNode = new Node(currentChar);
currentNode->children[0] = newNode;
currentNode = newNode;
}
 INSERTION ALGORITHM
Insert: Apple
So……….
Node *newNode = new Node(currentChar);

currentChar a

Node(curre
ntChar)
 INSERTION ALGORITHM
Insert: Apple
So……….
Node *newNode = new Node(currentChar);

currentChar a

Node(curre a
ntChar)
 INSERTION ALGORITHM
Insert: Apple
So……….
Node *newNode = new Node(currentChar);

currentChar a

Node(curre a
ntChar)

newNode a
All 26 Children Of newNode Will Point To The NULL
 INSERTION ALGORITHM
Insert: Apple
So……….
currentNode->children[0] = newNode;

newNode a currentNode Root

0
 INSERTION ALGORITHM
Insert: Apple
So……….
currentNode->children[0] = newNode;

newNode currentNode Root

0

a
 INSERTION ALGORITHM
Insert: Apple
So……….
currentNode = newNode;

newNode currentNode Root

0

a
 INSERTION ALGORITHM
Insert: Apple
Now Check If It Is The Last Character Of The Word Has Been Reached
if (i == word.size() - 1)
{
currentNode->end = true;
}

0 == 4? NO  Won’t Execute

 INSERTION ALGORITHM
Insert: Apple
So……….

newNode currentNode Root

0

bool end will be false

 INSERTION ALGORITHM
Insert: Apple
Root
0

currentNode a
 INSERTION ALGORITHM
Insert: Apple

A p p l e
0 1 2 3 4

char currentChar = tolower(word.at(1));

currentChar p
 INSERTION ALGORITHM
Insert: Apple

Then Get The Correct Index For The Appropriate Character

int index = currentChar - 'a';

So……….
currentChar p

int index = currentChar - 'a'; int index = p - 'a';

int index = 15;

 INSERTION ALGORITHM
Insert: Apple
Check If The Current Node Has The Current Character As One Of Its
Descendants
if (currentNode->children[15] != NULL)
{
currentNode = currentNode->children[15];
}

a
false
1 1 2 2
… … … If 15 Pointing To The NULL?
5 0 0 6

NULL
 INSERTION ALGORITHM
Insert: Apple
Check If The Current Node Has The Current Character As One Of Its
Descendants
if (currentNode->children[15] != NULL)
{
currentNode = currentNode->children[15];
} Here 15 Is The Index Value ( p – ‘a’ )
a Is 15 Pointing To The NULL?
false
1 1 2 2 YES!
… … …
5 0 0 6
So IF Statement Won’t Execute…………
And The Current Node Doesn't have the current
NULL
character as one of its descendants
 INSERTION ALGORITHM
Insert: Apple
So………. Node Constructor
else
{
Node *newNode = new Node(currentChar);
currentNode->children[15] = newNode;
currentNode = newNode;
}
 INSERTION ALGORITHM
Insert: Apple
So……….
Node *newNode = new Node(currentChar);

currentChar p

Node(curre
ntChar)
 INSERTION ALGORITHM
Insert: Apple
So……….
Node *newNode = new Node(currentChar);

currentChar p

Node(curre p
ntChar)
 INSERTION ALGORITHM
Insert: Apple
So……….
Node *newNode = new Node(currentChar);

currentChar p

Node(curre p
ntChar)

newNode p
All 26 Children Of newNode Will Point To The NULL
 INSERTION ALGORITHM
Insert: Apple
So……….
currentNode->children[15] = newNode;

newNode p currentNode a
1
5
 INSERTION ALGORITHM
Insert: Apple
So……….
currentNode->children[15] = newNode;

newNode currentNode a
1
5

p
 INSERTION ALGORITHM
Insert: Apple
So……….
currentNode = newNode;

newNode currentNode a
1
5

p
 INSERTION ALGORITHM
Insert: Apple
Now Check If It Is The Last Character Of The Word Has Been Reached
if (i == word.size() - 1)
{
currentNode->end = true;
}

1 == 4? NO  Won’t Execute

 INSERTION ALGORITHM
Insert: Apple
So……….

newNode currentNode a
1
5

bool end will be false

 INSERTION ALGORITHM
Insert: Apple
Root
0

currentNode a
1
5

p
 INSERTION ALGORITHM
Insert: Apple

SIMILARLY
 INSERTION ALGORITHM
Insert: Apple
Root
0

a
1
5

p
1
5

p
 INSERTION ALGORITHM
Insert: Apple
Root
0

a
1
5

p
1
5

p
1
1

l
 INSERTION ALGORITHM
Insert: Apple
Root
0

a
1
5

p
1
5

p
1
1

l
4

e
 INSERTION ALGORITHM
Insert: Apple
Now Check If It Is The Last Character Of The Word Has Been Reached
if (i == word.size() - 1)
{
currentNode->end = true;
}

4 == 4? YES  Will Execute

 INSERTION ALGORITHM
Insert: Apple
Root
0

a
1
5

p
1
5

p
1
1

l
4

bool end will be True

INSERTION ALGORITHM

Now Insert: Army

 INSERTION ALGORITHM
Insert: Army

A r m y
0 1 2 3
 INSERTION ALGORITHM
Insert: Army

A r m y
0 1 2 3

char currentChar = tolower(word.at(0));

currentChar a
 INSERTION ALGORITHM
Insert: Army

Then Get The Correct Index For The Appropriate Character

int index = currentChar - 'a';

So……….
currentChar a

int index = currentChar - 'a'; int index = a - 'a';

int index = 0;
 INSERTION ALGORITHM
Insert: Army

Declare A Pointer Node Type Pointer Variable That Point To The Root

Node *currentNode = root;

currentNode Root
Pointing To
 DELETE ALGORITHM
Delete: Army
Root
0

currentNode
a
1 1
5 7

p
1
5

p
1
1

l
4

bool end will be True

 INSERTION ALGORITHM
Insert: Army
Check If The Current Node Has The Current Character As One Of Its
Descendants
if (currentNode->children[0] != NULL)
{
currentNode = currentNode->children[0];
}

false
1 2 2
0 … … … If 0 Pointing To The NULL?
0 0 6

NULL
 INSERTION ALGORITHM
Insert: Army
Check If The Current Node Has The Current Character As One Of Its
Descendants
if (currentNode->children[0] != NULL)
{
currentNode = currentNode->children[0];
} Here 0 Is The Index Value ( a – ‘a’ )
Is 0 Pointing To The NULL?
false
1 2 2 NO!
0 … … …
0 0 6
So IF Statement Will Execute…………

NULL
 INSERTION ALGORITHM
Insert: Army
So……….
currentNode = currentNode->children[0];
 INSERTION ALGORITHM
Insert: Army
Root
0

currentNode
a
1
5

p
1
5

p
1
1

l
4

bool end will be True

 INSERTION ALGORITHM
Insert: Army
Now Check If It Is The Last Character Of The Word Has Been Reached
if (i == word.size() - 1)
{
currentNode->end = true;
}

0 == 3? NO  Won’t Execute

 INSERTION ALGORITHM
Insert: Army

A r m y
0 1 2 3

char currentChar = tolower(word.at(1));

currentChar r
 INSERTION ALGORITHM
Insert: Army

Then Get The Correct Index For The Appropriate Character

int index = currentChar - 'a';

So……….
currentChar r

int index = currentChar - 'a'; int index = r - 'a';

int index = 17;

 INSERTION ALGORITHM
Insert: Army
Check If The Current Node Has The Current Character As One Of Its
Descendants
if (currentNode->children[17] != NULL)
{
currentNode = currentNode->children[17];
}

a
false
1 1 2 2
… … … If 15 Pointing To The NULL?
7 0 0 6

NULL
 INSERTION ALGORITHM
Insert: Army
Check If The Current Node Has The Current Character As One Of Its
Descendants
if (currentNode->children[17] != NULL)
{
currentNode = currentNode->children[17];
} Here 17 Is The Index Value ( r – ‘a’ )
a Is 17 Pointing To The NULL?
false
1 1 2 2 YES!
… … …
7 0 0 6
So IF Statement Won’t Execute…………
And The Current Node Doesn't have the current
NULL
character as one of its descendants
 INSERTION ALGORITHM
Insert: Army
So………. Node Constructor
else
{
Node *newNode = new Node(currentChar);
currentNode->children[17] = newNode;
currentNode = newNode;
}
 INSERTION ALGORITHM
Insert: Army
So……….
Node *newNode = new Node(currentChar);

currentChar r

Node(curre
ntChar)
 INSERTION ALGORITHM
Insert: Army
So……….
Node *newNode = new Node(currentChar);

currentChar r

Node(curre r
ntChar)
 INSERTION ALGORITHM
Insert: Army
So……….
Node *newNode = new Node(currentChar);

currentChar r

Node(curre r
ntChar)

newNode r
All 26 Children Of newNode Will Point To The NULL
 INSERTION ALGORITHM
Insert: Army
So……….
currentNode->children[17] = newNode;
 INSERTION ALGORITHM
Insert: Army
Root
0

currentNode a
1 1
5 7

p
1
5
r

p
1
1

l
4

bool end will be True

 INSERTION ALGORITHM
Insert: Army
So……….
currentNode = newNode;
 INSERTION ALGORITHM
Insert: Army
Root
0

currentNode a
1 1
5 7

p
1
5
r

p
1
1

l
4

bool end will be True

 INSERTION ALGORITHM
Insert: Army
Now Check If It Is The Last Character Of The Word Has Been Reached
if (i == word.size() - 1)
{
currentNode->end = true;
}

1 == 3? NO  Won’t Execute

 INSERTION ALGORITHM
Insert: Army

SIMILARLY
 INSERTION ALGORITHM
Insert: Army
Root
0

a
1 1
5 7

p
1
5
r
1
2

p
1
1 m
1
5

l
4

bool end will be True

 INSERTION ALGORITHM
Insert: Army
Root
0

a
1 1
5 7

p
1
5
r
1
2

p
1
1 m
1
5

l
4

bool end will be True

 INSERTION ALGORITHM
Insert: Army
Now Check If It Is The Last Character Of The Word Has Been Reached
if (i == word.size() - 1)
{
currentNode->end = true;
}

3 == 3? YES  Will Execute

 INSERTION ALGORITHM
Insert: Army
Root
0

a
1 1
5 7

p
1
5
r
1
2

p
1
1 m
1
5

l
4

bool end will be True

DELETION
 DELETION ALGORITHM
Delete: Army

A r m y
0 1 2 3

char currentChar = tolower(word.at(0));

currentChar a
 DELETION ALGORITHM
Delete: Army

Then Get The Correct Index For The Appropriate Character

int index = currentChar - 'a';

So……….
currentChar a

int index = currentChar - 'a'; int index = a - 'a';

int index = 0;
 DELETION ALGORITHM
Delete: Army

Declare A Pointer Node Type Pointer Variable That Point To The Root

Node *currentNode = root;

currentNode Root
Pointing To
 DELETION ALGORITHM
Delete: Army
Root
0

currentNode
a
1 1
5 7

p
1
5
r
1
2

p
1
1 m
1
5

l
4

bool end will be True

 DELETION ALGORITHM
Delete: Army
Check If The Current Node Has The Current Character As One Of Its
Descendants
if (currentNode->children[0] != NULL)
{
currentNode = currentNode->children[0];
}

false
1 2 2
0 … … … If 0 Pointing To The NULL?
0 0 6

NULL
 DELETION ALGORITHM
Delete: Army
Check If The Current Node Has The Current Character As One Of Its
Descendants
if (currentNode->children[0] != NULL)
{
currentNode = currentNode->children[0];
} Here 0 Is The Index Value ( a – ‘a’ )
Is 0 Pointing To The NULL?
false
1 2 2 NO!
0 … … …
0 0 6
So IF Statement Will Execute…………

NULL
 DELETION ALGORITHM
Delete: Army
So……….
currentNode = currentNode->children[0];
 DELETION ALGORITHM
Delete: Army
Root
0

currentNode
a
1 1
5 7

p
1
5
r
1
2

p
1
1 m
1
5

l
4

bool end will be True

 DELETION ALGORITHM
Delete: Army

A r m y
0 1 2 3

char currentChar = tolower(word.at(1));

currentChar r
 DELETION ALGORITHM
Delete: Army

Then Get The Correct Index For The Appropriate Character

int index = currentChar - 'a';

So……….
currentChar r

int index = currentChar - 'a'; int index = r - 'a';

int index = 17;

 DELETION ALGORITHM
Delete: Army
Check If The Current Node Has The Current Character As One Of Its
Descendants
if (currentNode->children[17] != NULL)
{
currentNode = currentNode->children[17];
}

a
false
1 1 2 2
… … … If 15 Pointing To The NULL?
7 0 0 6

NULL
 DELETION ALGORITHM
Delete: Army
Check If The Current Node Has The Current Character As One Of Its
Descendants
if (currentNode->children[17] != NULL)
{
currentNode = currentNode->children[17];
} Here 17 Is The Index Value ( r – ‘a’ )
a Is 17 Pointing To The NULL?
false
1 1 2 2 NO!
… … …
7 0 0 6
So IF Statement Will Execute…………

NULL
 DELETION ALGORITHM
Delete: Army
Root
0

currentNode
a
1 1
5 7

p
1
5
r
1
2

p
1
1 m
1
5

l
4

bool end will be True

 DELETION ALGORITHM
Delete: Army

SIMILARLY
 DELETION ALGORITHM
Delete: Army
Root
0

currentNode
a
1 1
5 7

p
1
5
r
1
2

p
1
1 m
1
5

l
4

bool end will be True

 DELETION ALGORITHM
Delete: Army
Root
0

currentNode
a
1 1
5 7

p
1
5
r
1
2

p
1
1 m
1
5

l
4

bool end will be True

 DELETION ALGORITHM
Delete: Army
Now Check If It Is The Last Character Of The Word Has Been Reached
if (i == word.size() – 1 && currentNode->end)
{
currentNode->end = false;
}

3 == 3? && currentNode  end? YES  Will Execute

 DELETION ALGORITHM
Delete: Army
Root
0

a
1 1
5 7

p
1
5
r
1
2

p
1
1 m
1
5

l
4
bool end will be False So Word Couldn’t
y Be Found By Search So The Word Is
Deleted.
e

bool end will be True

SEARCH
 SEARCHING ALGORITHM
Search: Army

A r m y
0 1 2 3

char currentChar = tolower(word.at(0));

currentChar a
 SEARCHING ALGORITHM
SEARCH: Army

Then Get The Correct Index For The Appropriate Character

int index = currentChar - 'a';

So……….
currentChar a

int index = currentChar - 'a'; int index = a - 'a';

int index = 0;
 SEARCHING ALGORITHM
Search: Army

Declare A Pointer Node Type Pointer Variable That Point To The Root

Node *currentNode = root;

currentNode Root
Pointing To
 SEARCHING ALGORITHM
Search: Army
Root
0

currentNode
a
1 1
5 7

p
1
5
r
1
2

p
1
1 m
1
5

l
4

bool end will be True

 SEARCHING ALGORITHM
Search: Army
Check If The Current Node Has The Current Character As One Of Its
Descendants
if (currentNode->children[0] != NULL)
{
currentNode = currentNode->children[0];
}

false
1 2 2
0 … … … If 0 Pointing To The NULL?
0 0 6

NULL
 SEARCHING ALGORITHM
Search: Army
Check If The Current Node Has The Current Character As One Of Its
Descendants
if (currentNode->children[0] != NULL)
{
currentNode = currentNode->children[0];
} Here 0 Is The Index Value ( a – ‘a’ )
Is 0 Pointing To The NULL?
false
1 2 2 NO!
0 … … …
0 0 6
So IF Statement Will Execute…………

NULL
 SEARCHING ALGORITHM
Search: Army
So……….
currentNode = currentNode->children[0];
 SEARCHING ALGORITHM
Search: Army
Root
0

currentNode
a
1 1
5 7

p
1
5
r
1
2

p
1
1 m
1
5

l
4

bool end will be True

 SEARCHING ALGORITHM
Search: Army

A r m y
0 1 2 3

char currentChar = tolower(word.at(1));

currentChar r
 SEARCHING ALGORITHM
Search: Army

Then Get The Correct Index For The Appropriate Character

int index = currentChar - 'a';

So……….
currentChar r

int index = currentChar - 'a'; int index = r - 'a';

int index = 17;

 SEARCHING ALGORITHM
Search: Army
Check If The Current Node Has The Current Character As One Of Its
Descendants
if (currentNode->children[17] != NULL)
{
currentNode = currentNode->children[17];
}

a
false
1 1 2 2
… … … If 15 Pointing To The NULL?
7 0 0 6

NULL
 SEARCHING ALGORITHM
Search: Army
Check If The Current Node Has The Current Character As One Of Its
Descendants
if (currentNode->children[17] != NULL)
{
currentNode = currentNode->children[17];
} Here 17 Is The Index Value ( r – ‘a’ )
a Is 17 Pointing To The NULL?
false
1 1 2 2 NO!
… … …
7 0 0 6
So IF Statement Will Execute…………

NULL
 SEARCHING ALGORITHM
Search: Army
Root
0

currentNode
a
1 1
5 7

p
1
5
r
1
2

p
1
1 m
1
5

l
4

bool end will be True

 SEARCHING ALGORITHM
Search: Army

SIMILARLY
 SEARCHING ALGORITHM
Search: Army
Root
0

currentNode
a
1 1
5 7

p
1
5
r
1
2

p
1
1 m
1
5

l
4

bool end will be True

 SEARCHING ALGORITHM
Search: Army
Root
0

currentNode
a
1 1
5 7

p
1
5
r
1
2

p
1
1 m
1
5

l
4

bool end will be True

 SEARCHING ALGORITHM
Search: Army
Now Check If It Is The Last Character Of The Word Has Been Reached
if (i == word.size() – 1 && currentNode->end)
{
return true;
}

3 == 3? && currentNode  end? YES  Will Execute

 SEARCHING ALGORITHM
Search: Army
Root
0

a
1 1
5 7

p
1
5
r
1
2

p
1
1 m
1
5

l
4
Return True. Item Found !
y

bool end will be True

PRINTING WORD
 PRINTING ALGORITHM
Root
0

a
1 1
5 7

p
1
5
r
1
2

p
1
1 m
1
5

l
4

bool end will be True

 PRINTING ALGORITHM
Trie::alphabetize(Node * node, string prefix = "")
{
if (node->end)
cout << prefix << endl;

for (int i = 0; i < 26; ++i)

{
if (node->children[i] != NULL)
{
string currentString = prefix + node->children[i]->value;
alphabetize(node->children[i], currentString);
}
}
}
 PRINTING ALGORITHM
if (node->end) (1) Root
0

a
1 1
5 7

p
1
5
r
1
2

p
1
1 m
1
5

l
4

bool end will be True

 PRINTING ALGORITHM
Printing Result
CASE RESULT
CASE 1 FALSE
 PRINTING ALGORITHM
Trie::alphabetize(Node * node, string prefix = "")
{
if (node->end)
cout << prefix << endl;

for (int i = 0; i < 26; ++i)

{
if (node->children[i] != NULL)
{
string currentString = prefix + node->children[i]->value;
alphabetize(node->children[i], currentString);
}
}
}
 PRINTING ALGORITHM
if (node->children[0] != NULL) (2) Root
0

a
1 1
5 7

p
1
5
r
1
2

p
1
1 m
1
5

l
4

bool end will be True

 PRINTING ALGORITHM
Printing Result
CASE RESULT
CASE 1 FALSE
CASE 2 TRUE

string currentString = prefix + node->children[0]->value;

string currentString = “” +a;
string currentString = a;
alphabetize(node->children[0], currentString);
 PRINTING ALGORITHM
Trie::alphabetize(Node * node, string prefix = "")
{
if (node->end)
cout << prefix << endl;

for (int i = 0; i < 26; ++i)

{
if (node->children[i] != NULL)
{
string currentString = prefix + node->children[i]->value;
alphabetize(node->children[i], currentString);
}
}
}
 PRINTING ALGORITHM
if (node->children[1] != NULL) (3) Root
0

a
1 1
5 7

p
1
5
r
1
2

p
1
1 m
1
5

l
4

bool end will be True

 PRINTING ALGORITHM
Printing Result
CASE RESULT
CASE 3 FALSE
 PRINTING ALGORITHM
Trie::alphabetize(Node * node, string prefix = "")
{
if (node->end)
cout << prefix << endl;

for (int i = 0; i < 26; ++i)

{
if (node->children[i] != NULL)
{
string currentString = prefix + node->children[i]->value;
alphabetize(node->children[i], currentString);
}
}
}
 PRINTING ALGORITHM
if (node->children[2] != NULL) (4) Root
0

a
1 1
5 7

p
1
5
r
1
2

p
1
1 m
1
5

l
4

bool end will be True

 PRINTING ALGORITHM
Printing Result
CASE RESULT
CASE 4 FALSE
 PRINTING ALGORITHM
Trie::alphabetize(Node * node, string prefix = "")
{
if (node->end)
cout << prefix << endl;

for (int i = 0; i < 26; ++i)

{
if (node->children[i] != NULL)
{
string currentString = prefix + node->children[i]->value;
alphabetize(node->children[i], currentString);
}
}
}
 PRINTING ALGORITHM
if (node->children[15] != NULL) Root
(17) 0

a
1 1
5 7

p
1
5
r
1
2

p
1
1 m
1
5

l
4

bool end will be True

 PRINTING ALGORITHM
Printing Result
CASE RESULT
CASE 17 TRUE

string currentString = prefix + node->children[15]->value;

string currentString = a + p;
string currentString = ap;
alphabetize(node->children[15], currentString);
 PRINTING ALGORITHM
Trie::alphabetize(Node * node, string prefix = "")
{
if (node->end)
cout << prefix << endl;

for (int i = 0; i < 26; ++i)

{
if (node->children[i] != NULL)
{
string currentString = prefix + node->children[i]->value;
alphabetize(node->children[i], currentString);
}
}
}
 PRINTING ALGORITHM
if (node->children[15] != NULL) Root
(18) 0

a
1 1
5 7

p
1
5
r
1
2

p
1
1 m
1
5

l
4

bool end will be True

 PRINTING ALGORITHM
Printing Result
CASE RESULT
CASE 18 TRUE

string currentString = prefix + node->children[15]->value;

string currentString = ap + p;
string currentString = app;
alphabetize(node->children[15], currentString);
PRINTING ALGORITHM

SIMILARLY
 PRINTING ALGORITHM
Trie::alphabetize(Node * node, string prefix = "")
{
if (node->end)
cout << prefix << endl;

for (int i = 0; i < 26; ++i)

{
if (node->children[i] != NULL)
{
string currentString = prefix + node->children[i]->value;
alphabetize(node->children[i], currentString);
}
}
}
 PRINTING ALGORITHM
if (node->children[4] != NULL) Root
(19) 0

a
1 1
5 7

p
1
5
r
1
2

p
1
1 m
1
5

l
4

bool end will be True

 PRINTING ALGORITHM
Trie::alphabetize(Node * node, string prefix = "")
{
if (node->end)
cout << prefix << endl;

for (int i = 0; i < 26; ++i)

{
if (node->children[i] != NULL)
{
string currentString = prefix + node->children[i]->value;
alphabetize(node->children[i], currentString);
}
}
}
 PRINTING ALGORITHM
Printing Result
CASE RESULT
CASE 19 TRUE

string currentString = prefix + node->children[15]->value;

string currentString = appl + e;
string currentString = apple;
alphabetize(node->children[4], currentString);
PRINTING ALGORITHM
Printing Result

Print  apple
PRINTING ALGORITHM

SIMILARLY
PRINTING ALGORITHM
Printing Result

Print  apple
Print  army
Trie.h
SOURCE CODE
#ifndef TRIE_H
#define TRIE_H
#include <iostream>
#include <vector>
#include <string>
#include <assert.h>
#include <new>
using namespace std;
class Trie
{
public:
Trie();
void addWord(string word);
bool searchForWord(string word);
void deleteWord(string word);
Node *getRoot();
void alphabetize(Node *, string);

class Node private:

{
public: Node *root;
};
char value;
bool end; #endif // TRIE_H
Node *children[26];
Node(char value);
};
Trie.c
SOURCE CODE
#ifndef TRIE_CPP Trie::Trie()
#define TRIE_CPP {
root = new Node(' ');
#include <iostream> root->end = true;
#include "trie.h" }

using namespace std; Node *Trie::getRoot()

{
Node::Node(char value) return root;
{ }
this->value = value;

end = false;

for(int i = 0; i < 26; ++i)

{
children[i] = NULL;
}
}
Trie.c
SOURCE CODE
void Trie::addWord(string word) else
{ {
Node * currentNode = root; // the current node doesn't have the current character as one of its
decendants
Node * newNode = new Node(currentChar);
for (int i = 0; i < (int)word.size(); ++i)
currentNode->children[index] = newNode;
{
currentNode = newNode;
char currentChar = tolower(word.at(i));
}
int index = currentChar - 'a';
if (i == (int)word.size() - 1)
assert(index >= 0); // Makes sure the character is between a-z
{
if (currentNode->children[index] != NULL)
// the last character of the word has been reached
{
currentNode->end = true;
// check if the current node has the current character as one of its
decendants }
currentNode = currentNode->children[index]; }
} }
Trie.c
SOURCE CODE
bool Trie::searchForWord(string word) else
{ {
Node *currentNode = root; return false;
}
for(int i = 0; i < (int)word.size(); ++i)
{ if(i == (int)word.size() - 1 && !currentNode->end)
char currentChar = tolower(word.at(i)); {
int index = currentChar - 'a'; return false;
}
assert(index >= 0); }

if(currentNode->children[index] != NULL) return true;

{ }
currentNode = currentNode->children[index];
}
Trie.c
SOURCE CODE
void Trie::deleteWord(string word) else
{ {
Node *currentNode = root; return;
}
for(int i = 0; i < (int)word.size(); ++i)
{ if(i == (int)word.size() - 1 && currentNode->end)
char currentChar = tolower(word.at(i)); {
int index = currentChar - 'a'; currentNode->end = false;
}
assert(index >= 0); }
}
if(currentNode->children[index] != NULL)
{
currentNode = currentNode->children[index];
}
Trie.c
SOURCE CODE
void Trie::alphabetize(Node *node, string prefix = "")
{
if (node->end)
cout << prefix << endl;
for (int i = 0; i < 26; ++i)
{
if (node->children[i] != NULL)
{
string currentString = prefix + node->children[i]->value;
alphabetize(node->children[i], currentString);
}
}
}

#endif // TRIE_CPP
Main.cpp
SOURCE CODE
#include <iostream>
#include “trie.h” return 0;
}
using namespace std;
int main()
{
Trie * t = new Trie();

t->addWord("Carlos");
t->addWord("Perea");
t->addWord("Hello");
t->addWord("Ball");
t->addWord("Balloon");
t->addWord("Show");
t->addWord("Shower");

t->alphabetize(t->getRoot(), "");

t-> alphabetize(t->getRoot(), "");

OUTPUT
APPLICATIONS OF TRIE DATA
STRUCTURES
 TRIES IN AUTO COMPLETE
• Since a trie is a tree-like data structure in which each node
contains an array of pointers, one pointer for each character in the
alphabet.

• Starting at the root node, we can trace a word by following

pointers corresponding to the letters in the target word.

• Starting from the root node, you can check if a word exists in the
trie easily by following pointers corresponding to the letters in the
 TRIES IN AUTO COMPLETE

• Auto-complete functionality is used widely over the internet and

mobile apps. A lot of websites and apps try to complete your input
as soon as you start typing.

• All the descendants of a node have a common prefix of the string

associated with that node.
TRIES IN AUTO COMPLETE
AUTO COMPLETE IN GOOGLE SEARCH
 WHY TRIES IN AUTO COMPLETE

• Implementing auto complete using a trie is easy.

• We simply trace pointers to get to a node that represents the string

the user entered. By exploring the trie from that node down, we
can enumerate all strings that complete user’s input.
 AUTOMATIC COMMAND COMPLETION

• When using an operating system such as Unix or DOS, we type in

system commands to accomplish certain tasks. For example, the
Unix and DOS command cd may be used to change the current
directory.
SPELL CHECKERS
PHONE BOOK SEARCH
THANKS TO EVRYONE