Suffix Tries

A suffix trie is a type of trie mainly used for representing all the suffixes of a string. It is a tree where each node represents the suffix of a string. The root node is the entire string, and each child node is a suffix of the string that's one character shorter than the parent node's suffix.

For example, consider the string "banana". The suffix trie for this string would look like this:

 root / | \ b a n / | \ a n a / | \ n a n / | \ a n a / | \ n a $ / | a $ / $ 

Each path from the root to a leaf node represents a suffix of the string. The leaf nodes represent the end of a suffix, and the dollar sign ($) is used to indicate the end of the string.

The children store entire word instead of characters.

Features of Suffix Tries

Following are the Features of Suffix Tries −

It is trie, so it stores suffixes of string in trie data structure. for string of length n, there are n suffixes.

We can say compact representation of all suffixes of a string. Means, to save space, it becomes Suffix Tree by collapsing the nodes with only one child.

Suffix tries are effective for sub-string searches, pattern matching, and other string-related operations.

Operations on Suffix Tries

Some of the common operations on suffix tries include:

• Insertion: Insert a new suffix into the trie.
• Deletion: Remove a suffix from the trie.
• Search: Find a specific suffix in the trie.

Insertion Operation on Suffix Tries

We can insert a new suffix into the trie by following these steps:

 1. Start at the root node. 2. For each character in the suffix: a. If the character is not in the current node's children, create a new node for the same. b. Then move to the child node corresponding to the character and repeat the process. 3. Repeat the process for all character in the suffix. 4. Mark the last node as a leaf node to indicate the end of the suffix. 

Code for Insertion Operation

For example, to insert the suffix "ana" into the trie, we would follow these steps:

 // C Program to insert a suffix into a trie #include <stdio.h> #include <stdlib.h> #define ALPHABET_SIZE 26 // Structure for trie node struct TrieNode { struct TrieNode* children[ALPHABET_SIZE]; int isEndOfWord; }; // Function to create a new trie node struct TrieNode* createNode() { struct TrieNode* node = (struct TrieNode*)malloc(sizeof(struct TrieNode)); node->isEndOfWord = 0; for (int i = 0; i < ALPHABET_SIZE; i++) { node->children[i] = NULL; } return node; } // Function to insert a suffix into the trie void insert(struct TrieNode* root, const char* suffix) { struct TrieNode* current = root; for (int i = 0; suffix[i] != '\0'; i++) { int index = suffix[i] - 'a'; if (current->children[index] == NULL) { current->children[index] = createNode(); } current = current->children[index]; } current->isEndOfWord = 1; } // Display the trie void display(struct TrieNode* root, char str[], int level) { if (root->isEndOfWord) { str[level] = '\0'; printf("%s\n", str); } for (int i = 0; i < ALPHABET_SIZE; i++) { if (root->children[i] != NULL) { str[level] = i + 'a'; display(root->children[i], str, level + 1); } } } int main() { struct TrieNode* root = createNode(); insert(root, "banana"); insert(root, "ana"); insert(root, "na"); insert(root, "a"); insert(root, "$"); char str[20]; // Allocating memory for string buffer display(root, str, 0); return 0; } 

 a ana banana na 

 // C++ Program to insert a suffix into a trie #include <iostream> #include <vector> using namespace std; #define ALPHABET_SIZE 26 // Structure for trie node struct TrieNode { TrieNode* children[ALPHABET_SIZE]; bool isEndOfWord; }; // Function to create a new trie node TrieNode* createNode() { TrieNode* node = new TrieNode(); node->isEndOfWord = false; for (int i = 0; i < ALPHABET_SIZE; i++) { node->children[i] = NULL; } return node; } // Function to insert a suffix into the trie void insert(TrieNode* root, const string& suffix) { TrieNode* current = root; for (char c : suffix) { int index = c - 'a'; if (current->children[index] == NULL) { current->children[index] = createNode(); } current = current->children[index]; } current->isEndOfWord = true; } // Display the trie void display(TrieNode* root, char str[], int level) { if (root->isEndOfWord) { str[level] = '\0'; cout << str << endl; } for (int i = 0; i < ALPHABET_SIZE; i++) { if (root->children[i] != NULL) { str[level] = i + 'a'; display(root->children[i], str, level + 1); } } } int main() { TrieNode* root = createNode(); insert(root, "banana"); insert(root, "ana"); insert(root, "na"); insert(root, "a"); insert(root, "$"); char str[20]; // Allocating memory for string buffer display(root, str, 0); return 0; } 

 a ana banana na 

 // Java Program to insert a suffix into a trie class TrieNode { TrieNode[] children; boolean isEndOfWord; TrieNode() { children = new TrieNode[26]; // Only 'a' to 'z' isEndOfWord = false; } } public class Main { static final int ALPHABET_SIZE = 26; // Function to insert a suffix into the trie static void insert(TrieNode root, String suffix) { TrieNode current = root; for (int i = 0; i < suffix.length(); i++) { char ch = suffix.charAt(i); // Ignore non-alphabet characters if (ch < 'a' || ch > 'z') continue; int index = ch - 'a'; if (current.children[index] == null) { current.children[index] = new TrieNode(); } current = current.children[index]; } current.isEndOfWord = true; } // Display the trie static void display(TrieNode root, char[] str, int level) { if (root.isEndOfWord) { System.out.println(new String(str, 0, level)); // Correct substring printing } for (int i = 0; i < ALPHABET_SIZE; i++) { if (root.children[i] != null) { str[level] = (char) (i + 'a'); display(root.children[i], str, level + 1); } } } public static void main(String[] args) { TrieNode root = new TrieNode(); insert(root, "banana"); insert(root, "ana"); insert(root, "na"); insert(root, "a"); insert(root, "$"); // '$' will be ignored safely char[] str = new char[20]; // Allocating memory for string buffer display(root, str, 0); } } 

 a ana banana na 

 # Python Program to insert a suffix into a trie # Python Program to insert a suffix into a trie class TrieNode: def __init__(self): self.children = [None] * 26 # Only for 'a' to 'z' self.isEndOfWord = False # Function to insert a suffix into the trie def insert(root, suffix): current = root for c in suffix: # Ignore non-alphabet characters if not ('a' <= c <= 'z'): continue # Skip invalid characters index = ord(c) - ord('a') if current.children[index] is None: current.children[index] = TrieNode() current = current.children[index] current.isEndOfWord = True # Display the trie def display(root, str, level): if root.isEndOfWord: print(''.join(str[:level])) # Print valid words for i in range(26): if root.children[i] is not None: str[level] = chr(i + ord('a')) display(root.children[i], str, level + 1) if __name__ == '__main__': root = TrieNode() insert(root, "banana") insert(root, "ana") insert(root, "na") insert(root, "a") insert(root, "$") # '$' will be ignored safely str = [''] * 20 # Allocating memory for string buffer display(root, str, 0) 

 a ana banana na 

Deletion and Search Operations on Suffix Tries

Deletion and search operations on suffix tries are similar to insertion. We can delete a suffix by removing the corresponding leaf node from the trie. To search for a specific suffix, we can traverse the trie from the root node to the leaf node corresponding to the suffix.

Following are the steps to delete a suffix from the trie:

 1. Start at the root node. 2. For each character in the suffix: a. Move to the child node corresponding to the character. 3. Mark the last node as a non-leaf node to delete the suffix. 

Following are the steps to search for a specific suffix in the trie:

 1. Start at the root node. 2. For each character in the suffix: a. Move to the child node corresponding to the character. 3. Check if the last node is a leaf node to find the suffix. 

Code for Deletion and Search Operations

Here is the code for deletion and search operations on suffix tries:

 // C Program to delete and search a suffix in a trie #include <stdio.h> #include <stdlib.h> #define ALPHABET_SIZE 26 // Structure for trie node struct TrieNode { struct TrieNode* children[ALPHABET_SIZE]; int isEndOfWord; }; // Function to create a new trie node struct TrieNode* createNode() { struct TrieNode* node = (struct TrieNode*)malloc(sizeof(struct TrieNode)); node->isEndOfWord = 0; for (int i = 0; i < ALPHABET_SIZE; i++) { node->children[i] = NULL; } return node; } // Function to insert a suffix into the trie void insert(struct TrieNode* root, const char* suffix) { struct TrieNode* current = root; for (int i = 0; suffix[i] != '\0'; i++) { int index = suffix[i] - 'a'; if (current->children[index] == NULL) { current->children[index] = createNode(); } current = current->children[index]; } current->isEndOfWord = 1; } // Function to delete a suffix from the trie void delete(struct TrieNode* root, const char* suffix) { struct TrieNode* current = root; for (int i = 0; suffix[i] != '\0'; i++) { int index = suffix[i] - 'a'; if (current->children[index] == NULL) { return; // Suffix not found } current = current->children[index]; } current->isEndOfWord = 0; } // Function to search for a suffix in the trie int search(struct TrieNode* root, const char* suffix) { struct TrieNode* current = root; for (int i = 0; suffix[i] != '\0'; i++) { int index = suffix[i] - 'a'; if (current->children[index] == NULL) { return 0; // Suffix not found } current = current->children[index]; } return current->isEndOfWord; } int main() { struct TrieNode* root = createNode(); insert(root, "banana"); insert(root, "ana"); insert(root, "na"); insert(root, "a"); insert(root, "$"); printf("Search for 'ana': %s\n", search(root, "ana") ? "Found" : "Not found"); delete(root, "ana"); printf("After deletion:\n"); printf("Search for 'ana': %s\n", search(root, "ana") ? "Found" : "Not found"); printf("Search for 'na': %s\n", search(root, "na") ? "Found" : "Not found"); return 0; } 

 Search for 'ana': Found After deletion: Search for 'ana': Not found Search for 'na': Found 

 // C++ Program to delete and search a suffix in a trie #include <iostream> #include <vector> using namespace std; #define ALPHABET_SIZE 26 // Structure for trie node struct TrieNode { TrieNode* children[ALPHABET_SIZE]; bool isEndOfWord; }; // Function to create a new trie node TrieNode* createNode() { TrieNode* node = new TrieNode(); node->isEndOfWord = false; for (int i = 0; i < ALPHABET_SIZE; i++) { node->children[i] = NULL; } return node; } // Function to insert a suffix into the trie void insert(TrieNode* root, const string& suffix) { TrieNode* current = root; for (char c : suffix) { int index = c - 'a'; if (current->children[index] == NULL) { current->children[index] = createNode(); } current = current->children[index]; } current->isEndOfWord = true; } // Function to delete a suffix from the trie void deleteN(TrieNode* root, const string& suffix) { TrieNode* current = root; for (char c : suffix) { int index = c - 'a'; if (current->children[index] == NULL) { return; // Suffix not found } current = current->children[index]; } current->isEndOfWord = false; } // Function to search for a suffix in the trie bool search(TrieNode* root, const string& suffix) { TrieNode* current = root; for (char c : suffix) { int index = c - 'a'; if (current->children[index] == NULL) { return false; // Suffix not found } current = current->children[index]; } return current->isEndOfWord; } int main() { TrieNode* root = createNode(); insert(root, "banana"); insert(root, "ana"); insert(root, "na"); insert(root, "a"); insert(root, "$"); cout << "Search for 'ana': " << (search(root, "ana") ? "Found" : "Not found") << endl; deleteN(root, "ana"); cout << "After deletion:\n"; cout << "Search for 'ana': " << (search(root, "ana") ? "Found" : "Not found") << endl; cout << "Search for 'na': " << (search(root, "na") ? "Found" : "Not found") << endl; return 0; } 

 Search for 'ana': Found After deletion: Search for 'ana': Not found Search for 'na': Found 

 // Java Program to delete and search a suffix in a trie class TrieNode { TrieNode[] children; boolean isEndOfWord; TrieNode() { children = new TrieNode[26]; // Only 'a' to 'z' isEndOfWord = false; } } public class Main { static final int ALPHABET_SIZE = 26; // Function to insert a suffix into the trie static void insert(TrieNode root, String suffix) { TrieNode current = root; for (int i = 0; i < suffix.length(); i++) { char ch = suffix.charAt(i); // Ignore non-alphabet characters if (ch < 'a' || ch > 'z') continue; int index = ch - 'a'; if (current.children[index] == null) { current.children[index] = new TrieNode(); } current = current.children[index]; } current.isEndOfWord = true; } // Function to delete a suffix from the trie static void delete(TrieNode root, String suffix) { TrieNode current = root; for (int i = 0; i < suffix.length(); i++) { char ch = suffix.charAt(i); // Ignore non-alphabet characters if (ch < 'a' || ch > 'z') return; int index = ch - 'a'; if (current.children[index] == null) { return; // Suffix not found } current = current.children[index]; } current.isEndOfWord = false; } // Function to search for a suffix in the trie static boolean search(TrieNode root, String suffix) { TrieNode current = root; for (int i = 0; i < suffix.length(); i++) { char ch = suffix.charAt(i); // Ignore non-alphabet characters if (ch < 'a' || ch > 'z') return false; int index = ch - 'a'; if (current.children[index] == null) { return false; // Suffix not found } current = current.children[index]; } return current.isEndOfWord; } public static void main(String[] args) { TrieNode root = new TrieNode(); insert(root, "banana"); insert(root, "ana"); insert(root, "na"); insert(root, "a"); insert(root, "$"); System.out.println("Search for 'ana': " + (search(root, "ana") ? "Found" : "Not found")); delete(root, "ana"); System.out.println("After deletion:"); System.out.println("Search for 'ana': " + (search(root, "ana") ? "Found" : "Not found")); System.out.println("Search for 'na': " + (search(root, "na") ? "Found" : "Not found")); } } 

 Search for 'ana': Found After deletion: Search for 'ana': Not found Search for 'na': Found 

 # Python Program to delete and search a suffix in a trie class TrieNode: def __init__(self): self.children = [None] * 26 # Only for 'a' to 'z' self.isEndOfWord = False # Function to insert a suffix into the trie def insert(root, suffix): current = root for c in suffix: # Ignore non-alphabet characters if not ('a' <= c <= 'z'): continue # Skip invalid characters index = ord(c) - ord('a') if current.children[index] is None: current.children[index] = TrieNode() current = current.children[index] current.isEndOfWord = True # Function to delete a suffix from the trie def delete(root, suffix): current = root for c in suffix: # Ignore non-alphabet characters if not ('a' <= c <= 'z'): return # Skip invalid characters index = ord(c) - ord('a') if current.children[index] is None: return # Suffix not found current = current.children[index] current.isEndOfWord = False # Function to search for a suffix in the trie def search(root, suffix): current = root for c in suffix: # Ignore non-alphabet characters if not ('a' <= c <= 'z'): return False # Skip invalid characters index = ord(c) - ord('a') if current.children[index] is None: return False # Suffix not found current = current.children[index] return current.isEndOfWord if __name__ == '__main__': root = TrieNode() insert(root, "banana") insert(root, "ana") insert(root, "na") insert(root, "a") insert(root, "$") print("Search for 'ana':", "Found" if search(root, "ana") else "Not found") delete(root, "ana") print("After deletion:") print("Search for 'ana':", "Found" if search(root, "ana") else "Not found") print("Search for 'na':", "Found" if search(root, "na") else "Not found") 

 Search for 'ana': Found After deletion: Search for 'ana': Not found Search for 'na': Found 

Time Complexity of Suffix Tries

The time complexity of suffix tries depends on the operations performed:

• Insertion: O(n) for inserting a suffix of length n into the trie.
• Deletion: O(n)
• Search: O(n)

Applications of Suffix Tries

Suffix tries are used in various applications, including:

• Pattern matching and substring search algorithms
• Text indexing and searching
• Genomic sequence analysis
• Spell checking and correction
• Biological sequence analysis
• Information retrieval
• Compression algorithms

Conclusion

In this chapter, we discussed suffix tries, a type of trie used for representing all the suffixes of a string. We explored the structure of a suffix trie, its features, operations, and applications. Suffix tries are a powerful data structure for substring searches, pattern matching, and other string-related operations.