# Suffix Tree Application 1 – Substring Check

Last Updated : 03 May, 2024

Given a text string and a pattern string, check if a pattern exists in text or not.
Few pattern searching algorithms (KMP, Rabin-Karp, Naive Algorithm, Finite Automata) are already discussed, which can be used for this check.
Here we will discuss suffix tree based algorithm.
As a prerequisite, we must know how to build a suffix tree in one or the other way.
Once we have a suffix tree built for given text, we need to traverse the tree from root to leaf against the characters in pattern. If we do not fall off the tree (i.e. there is a path from root to leaf or somewhere in middle) while traversal, then pattern exists in text as a substring.

Here we will build suffix tree using Ukkonen’s Algorithm, discussed already as below:
Ukkonen’s Suffix Tree Construction – Part 1
Ukkonen’s Suffix Tree Construction – Part 2
Ukkonen’s Suffix Tree Construction – Part 3
Ukkonen’s Suffix Tree Construction – Part 4
Ukkonen’s Suffix Tree Construction – Part 5
Ukkonen’s Suffix Tree Construction – Part 6
The core traversal implementation for substring check, can be modified accordingly for suffix trees built by other algorithms.

C++ ```// A C program for substring check using Ukkonen's Suffix // Tree Construction #include <bits/stdc++.h> using namespace std; #define MAX_CHAR 256 struct SuffixTreeNode { struct SuffixTreeNode* children[MAX_CHAR]; // pointer to other node via suffix link struct SuffixTreeNode* suffixLink; /*(start, end) interval specifies the edge, by which the node is connected to its parent node. Each edge will connect two nodes, one parent and one child, and (start, end) interval of a given edge will be stored in the child node. Let's say there are two nods A and B connected by an edge with indices (5, 8) then this indices (5, 8) will be stored in node B. */ int start; int* end; /*for leaf nodes, it stores the index of suffix for the path from root to leaf*/ int suffixIndex; }; typedef struct SuffixTreeNode Node; char text[100]; // Input string Node* root = NULL; // Pointer to root node /*lastNewNode will point to newly created internal node, waiting for it's suffix link to be set, which might get a new suffix link (other than root) in next extension of same phase. lastNewNode will be set to NULL when last newly created internal node (if there is any) got it's suffix link reset to new internal node created in next extension of same phase. */ Node* lastNewNode = NULL; Node* activeNode = NULL; /*activeEdge is represented as an input string character index (not the character itself)*/ int activeEdge = -1; int activeLength = 0; // remainingSuffixCount tells how many suffixes yet to // be added in tree int remainingSuffixCount = 0; int leafEnd = -1; int* rootEnd = NULL; int* splitEnd = NULL; int size = -1; // Length of input string Node* newNode(int start, int* end) { Node* node = (Node*)malloc(sizeof(Node)); int i; for (i = 0; i < MAX_CHAR; i++) node->children[i] = NULL; /*For root node, suffixLink will be set to NULL For internal nodes, suffixLink will be set to root by default in current extension and may change in next extension*/ node->suffixLink = root; node->start = start; node->end = end; /*suffixIndex will be set to -1 by default and actual suffix index will be set later for leaves at the end of all phases*/ node->suffixIndex = -1; return node; } int edgeLength(Node* n) { if (n == root) return 0; return *(n->end) - (n->start) + 1; } int walkDown(Node* currNode) { /*activePoint change for walk down (APCFWD) using Skip/Count Trick (Trick 1). If activeLength is greater than current edge length, set next internal node as activeNode and adjust activeEdge and activeLength accordingly to represent same activePoint*/ if (activeLength >= edgeLength(currNode)) { activeEdge += edgeLength(currNode); activeLength -= edgeLength(currNode); activeNode = currNode; return 1; } return 0; } void extendSuffixTree(int pos) { /*Extension Rule 1, this takes care of extending all leaves created so far in tree*/ leafEnd = pos; /*Increment remainingSuffixCount indicating that a new suffix added to the list of suffixes yet to be added in tree*/ remainingSuffixCount++; /*set lastNewNode to NULL while starting a new phase, indicating there is no internal node waiting for it's suffix link reset in current phase*/ lastNewNode = NULL; // Add all suffixes (yet to be added) one by one in tree while (remainingSuffixCount > 0) { if (activeLength == 0) activeEdge = pos; // APCFALZ // There is no outgoing edge starting with // activeEdge from activeNode if (activeNode->children[text[activeEdge]] == NULL) { // Extension Rule 2 (A new leaf edge gets // created) activeNode->children[text[activeEdge]] = newNode(pos, &leafEnd); /*A new leaf edge is created in above line starting from an existing node (the current activeNode), and if there is any internal node waiting for it's suffix link get reset, point the suffix link from that last internal node to current activeNode. Then set lastNewNode to NULL indicating no more node waiting for suffix link reset.*/ if (lastNewNode != NULL) { lastNewNode->suffixLink = activeNode; lastNewNode = NULL; } } // There is an outgoing edge starting with // activeEdge from activeNode else { // Get the next node at the end of edge starting // with activeEdge Node* next = activeNode->children[text[activeEdge]]; if (walkDown(next)) // Do walkdown { // Start from next node (the new activeNode) continue; } /*Extension Rule 3 (current character being processed is already on the edge)*/ if (text[next->start + activeLength] == text[pos]) { // If a newly created node waiting for it's // suffix link to be set, then set suffix // link of that waiting node to current // active node if (lastNewNode != NULL && activeNode != root) { lastNewNode->suffixLink = activeNode; lastNewNode = NULL; } // APCFER3 activeLength++; /*STOP all further processing in this phase and move on to next phase*/ break; } /*We will be here when activePoint is in the middle of the edge being traversed and current character being processed is not on the edge (we fall off the tree). In this case, we add a new internal node and a new leaf edge going out of that new node. This is Extension Rule 2, where a new leaf edge and a new internal node get created*/ splitEnd = (int*)malloc(sizeof(int)); *splitEnd = next->start + activeLength - 1; // New internal node Node* split = newNode(next->start, splitEnd); activeNode->children[text[activeEdge]] = split; // New leaf coming out of new internal node split->children[text[pos]] = newNode(pos, &leafEnd); next->start += activeLength; split->children[text[next->start]] = next; /*We got a new internal node here. If there is any internal node created in last extensions of same phase which is still waiting for it's suffix link reset, do it now.*/ if (lastNewNode != NULL) { /*suffixLink of lastNewNode points to current newly created internal node*/ lastNewNode->suffixLink = split; } /*Make the current newly created internal node waiting for it's suffix link reset (which is pointing to root at present). If we come across any other internal node (existing or newly created) in next extension of same phase, when a new leaf edge gets added (i.e. when Extension Rule 2 applies is any of the next extension of same phase) at that point, suffixLink of this node will point to that internal node.*/ lastNewNode = split; } /* One suffix got added in tree, decrement the count of suffixes yet to be added.*/ remainingSuffixCount--; if (activeNode == root && activeLength > 0) // APCFER2C1 { activeLength--; activeEdge = pos - remainingSuffixCount + 1; } else if (activeNode != root) // APCFER2C2 { activeNode = activeNode->suffixLink; } } } void print(int i, int j) { int k; for (k = i; k <= j; k++) printf("%c", text[k]); } // Print the suffix tree as well along with setting suffix // index So tree will be printed in DFS manner Each edge // along with it's suffix index will be printed void setSuffixIndexByDFS(Node* n, int labelHeight) { if (n == NULL) return; if (n->start != -1) // A non-root node { // Print the label on edge from parent to current // node Uncomment below line to print suffix tree // print(n->start, *(n->end)); } int leaf = 1; int i; for (i = 0; i < MAX_CHAR; i++) { if (n->children[i] != NULL) { // Uncomment below two lines to print suffix // index // if (leaf == 1 && n->start != -1) // printf(" [%d]\n", n->suffixIndex); // Current node is not a leaf as it has outgoing // edges from it. leaf = 0; setSuffixIndexByDFS( n->children[i], labelHeight + edgeLength(n->children[i])); } } if (leaf == 1) { n->suffixIndex = size - labelHeight; // Uncomment below line to print suffix index // printf(" [%d]\n", n->suffixIndex); } } void freeSuffixTreeByPostOrder(Node* n) { if (n == NULL) return; int i; for (i = 0; i < MAX_CHAR; i++) { if (n->children[i] != NULL) { freeSuffixTreeByPostOrder(n->children[i]); } } if (n->suffixIndex == -1) free(n->end); free(n); } /*Build the suffix tree and print the edge labels along with suffixIndex. suffixIndex for leaf edges will be >= 0 and for non-leaf edges will be -1*/ void buildSuffixTree() { size = strlen(text); int i; rootEnd = (int*)malloc(sizeof(int)); *rootEnd = -1; /*Root is a special node with start and end indices as -1, as it has no parent from where an edge comes to root*/ root = newNode(-1, rootEnd); activeNode = root; // First activeNode will be root for (i = 0; i < size; i++) extendSuffixTree(i); int labelHeight = 0; setSuffixIndexByDFS(root, labelHeight); } int traverseEdge(char* str, int idx, int start, int end) { int k = 0; // Traverse the edge with character by character // matching for (k = start; k <= end && str[idx] != '\0'; k++, idx++) { if (text[k] != str[idx]) return -1; // mo match } if (str[idx] == '\0') return 1; // match return 0; // more characters yet to match } int doTraversal(Node* n, char* str, int idx) { if (n == NULL) { return -1; // no match } int res = -1; // If node n is not root node, then traverse edge // from node n's parent to node n. if (n->start != -1) { res = traverseEdge(str, idx, n->start, *(n->end)); if (res != 0) return res; // match (res = 1) or no match (res // = -1) } // Get the character index to search idx = idx + edgeLength(n); // If there is an edge from node n going out // with current character str[idx], traverse that edge if (n->children[str[idx]] != NULL) return doTraversal(n->children[str[idx]], str, idx); else return -1; // no match } void checkForSubString(char* str) { int res = doTraversal(root, str, 0); if (res == 1) printf("Pattern <%s> is a Substring\n", str); else printf("Pattern <%s> is NOT a Substring\n", str); } // driver program to test above functions int main(int argc, char* argv[]) { strcpy(text, "THIS IS A TEST TEXT\$"); buildSuffixTree(); checkForSubString("TEST"); checkForSubString("A"); checkForSubString(" "); checkForSubString("IS A"); checkForSubString(" IS A "); checkForSubString("TEST1"); checkForSubString("THIS IS GOOD"); checkForSubString("TES"); checkForSubString("TESA"); checkForSubString("ISB"); // Free the dynamically allocated memory freeSuffixTreeByPostOrder(root); return 0; } ``` C ```// A C program for substring check using Ukkonen's Suffix // Tree Construction #include <stdio.h> #include <stdlib.h> #include <string.h> #define MAX_CHAR 256 struct SuffixTreeNode { struct SuffixTreeNode* children[MAX_CHAR]; // pointer to other node via suffix link struct SuffixTreeNode* suffixLink; /*(start, end) interval specifies the edge, by which the node is connected to its parent node. Each edge will connect two nodes, one parent and one child, and (start, end) interval of a given edge will be stored in the child node. Let's say there are two nods A and B connected by an edge with indices (5, 8) then this indices (5, 8) will be stored in node B. */ int start; int* end; /*for leaf nodes, it stores the index of suffix for the path from root to leaf*/ int suffixIndex; }; typedef struct SuffixTreeNode Node; char text[100]; // Input string Node* root = NULL; // Pointer to root node /*lastNewNode will point to newly created internal node, waiting for it's suffix link to be set, which might get a new suffix link (other than root) in next extension of same phase. lastNewNode will be set to NULL when last newly created internal node (if there is any) got it's suffix link reset to new internal node created in next extension of same phase. */ Node* lastNewNode = NULL; Node* activeNode = NULL; /*activeEdge is represented as an input string character index (not the character itself)*/ int activeEdge = -1; int activeLength = 0; // remainingSuffixCount tells how many suffixes yet to // be added in tree int remainingSuffixCount = 0; int leafEnd = -1; int* rootEnd = NULL; int* splitEnd = NULL; int size = -1; // Length of input string Node* newNode(int start, int* end) { Node* node = (Node*)malloc(sizeof(Node)); int i; for (i = 0; i < MAX_CHAR; i++) node->children[i] = NULL; /*For root node, suffixLink will be set to NULL For internal nodes, suffixLink will be set to root by default in current extension and may change in next extension*/ node->suffixLink = root; node->start = start; node->end = end; /*suffixIndex will be set to -1 by default and actual suffix index will be set later for leaves at the end of all phases*/ node->suffixIndex = -1; return node; } int edgeLength(Node* n) { if (n == root) return 0; return *(n->end) - (n->start) + 1; } int walkDown(Node* currNode) { /*activePoint change for walk down (APCFWD) using Skip/Count Trick (Trick 1). If activeLength is greater than current edge length, set next internal node as activeNode and adjust activeEdge and activeLength accordingly to represent same activePoint*/ if (activeLength >= edgeLength(currNode)) { activeEdge += edgeLength(currNode); activeLength -= edgeLength(currNode); activeNode = currNode; return 1; } return 0; } void extendSuffixTree(int pos) { /*Extension Rule 1, this takes care of extending all leaves created so far in tree*/ leafEnd = pos; /*Increment remainingSuffixCount indicating that a new suffix added to the list of suffixes yet to be added in tree*/ remainingSuffixCount++; /*set lastNewNode to NULL while starting a new phase, indicating there is no internal node waiting for it's suffix link reset in current phase*/ lastNewNode = NULL; // Add all suffixes (yet to be added) one by one in tree while (remainingSuffixCount > 0) { if (activeLength == 0) activeEdge = pos; // APCFALZ // There is no outgoing edge starting with // activeEdge from activeNode if (activeNode->children[text[activeEdge]] == NULL) { // Extension Rule 2 (A new leaf edge gets // created) activeNode->children[text[activeEdge]] = newNode(pos, &leafEnd); /*A new leaf edge is created in above line starting from an existing node (the current activeNode), and if there is any internal node waiting for it's suffix link get reset, point the suffix link from that last internal node to current activeNode. Then set lastNewNode to NULL indicating no more node waiting for suffix link reset.*/ if (lastNewNode != NULL) { lastNewNode->suffixLink = activeNode; lastNewNode = NULL; } } // There is an outgoing edge starting with // activeEdge from activeNode else { // Get the next node at the end of edge starting // with activeEdge Node* next = activeNode->children[text[activeEdge]]; if (walkDown(next)) // Do walkdown { // Start from next node (the new activeNode) continue; } /*Extension Rule 3 (current character being processed is already on the edge)*/ if (text[next->start + activeLength] == text[pos]) { // If a newly created node waiting for it's // suffix link to be set, then set suffix // link of that waiting node to current // active node if (lastNewNode != NULL && activeNode != root) { lastNewNode->suffixLink = activeNode; lastNewNode = NULL; } // APCFER3 activeLength++; /*STOP all further processing in this phase and move on to next phase*/ break; } /*We will be here when activePoint is in the middle of the edge being traversed and current character being processed is not on the edge (we fall off the tree). In this case, we add a new internal node and a new leaf edge going out of that new node. This is Extension Rule 2, where a new leaf edge and a new internal node get created*/ splitEnd = (int*)malloc(sizeof(int)); *splitEnd = next->start + activeLength - 1; // New internal node Node* split = newNode(next->start, splitEnd); activeNode->children[text[activeEdge]] = split; // New leaf coming out of new internal node split->children[text[pos]] = newNode(pos, &leafEnd); next->start += activeLength; split->children[text[next->start]] = next; /*We got a new internal node here. If there is any internal node created in last extensions of same phase which is still waiting for it's suffix link reset, do it now.*/ if (lastNewNode != NULL) { /*suffixLink of lastNewNode points to current newly created internal node*/ lastNewNode->suffixLink = split; } /*Make the current newly created internal node waiting for it's suffix link reset (which is pointing to root at present). If we come across any other internal node (existing or newly created) in next extension of same phase, when a new leaf edge gets added (i.e. when Extension Rule 2 applies is any of the next extension of same phase) at that point, suffixLink of this node will point to that internal node.*/ lastNewNode = split; } /* One suffix got added in tree, decrement the count of suffixes yet to be added.*/ remainingSuffixCount--; if (activeNode == root && activeLength > 0) // APCFER2C1 { activeLength--; activeEdge = pos - remainingSuffixCount + 1; } else if (activeNode != root) // APCFER2C2 { activeNode = activeNode->suffixLink; } } } void print(int i, int j) { int k; for (k = i; k <= j; k++) printf("%c", text[k]); } // Print the suffix tree as well along with setting suffix // index So tree will be printed in DFS manner Each edge // along with it's suffix index will be printed void setSuffixIndexByDFS(Node* n, int labelHeight) { if (n == NULL) return; if (n->start != -1) // A non-root node { // Print the label on edge from parent to current // node Uncomment below line to print suffix tree // print(n->start, *(n->end)); } int leaf = 1; int i; for (i = 0; i < MAX_CHAR; i++) { if (n->children[i] != NULL) { // Uncomment below two lines to print suffix // index // if (leaf == 1 && n->start != -1) // printf(" [%d]\n", n->suffixIndex); // Current node is not a leaf as it has outgoing // edges from it. leaf = 0; setSuffixIndexByDFS( n->children[i], labelHeight + edgeLength(n->children[i])); } } if (leaf == 1) { n->suffixIndex = size - labelHeight; // Uncomment below line to print suffix index // printf(" [%d]\n", n->suffixIndex); } } void freeSuffixTreeByPostOrder(Node* n) { if (n == NULL) return; int i; for (i = 0; i < MAX_CHAR; i++) { if (n->children[i] != NULL) { freeSuffixTreeByPostOrder(n->children[i]); } } if (n->suffixIndex == -1) free(n->end); free(n); } /*Build the suffix tree and print the edge labels along with suffixIndex. suffixIndex for leaf edges will be >= 0 and for non-leaf edges will be -1*/ void buildSuffixTree() { size = strlen(text); int i; rootEnd = (int*)malloc(sizeof(int)); *rootEnd = -1; /*Root is a special node with start and end indices as -1, as it has no parent from where an edge comes to root*/ root = newNode(-1, rootEnd); activeNode = root; // First activeNode will be root for (i = 0; i < size; i++) extendSuffixTree(i); int labelHeight = 0; setSuffixIndexByDFS(root, labelHeight); } int traverseEdge(char* str, int idx, int start, int end) { int k = 0; // Traverse the edge with character by character // matching for (k = start; k <= end && str[idx] != '\0'; k++, idx++) { if (text[k] != str[idx]) return -1; // mo match } if (str[idx] == '\0') return 1; // match return 0; // more characters yet to match } int doTraversal(Node* n, char* str, int idx) { if (n == NULL) { return -1; // no match } int res = -1; // If node n is not root node, then traverse edge // from node n's parent to node n. if (n->start != -1) { res = traverseEdge(str, idx, n->start, *(n->end)); if (res != 0) return res; // match (res = 1) or no match (res // = -1) } // Get the character index to search idx = idx + edgeLength(n); // If there is an edge from node n going out // with current character str[idx], traverse that edge if (n->children[str[idx]] != NULL) return doTraversal(n->children[str[idx]], str, idx); else return -1; // no match } void checkForSubString(char* str) { int res = doTraversal(root, str, 0); if (res == 1) printf("Pattern <%s> is a Substring\n", str); else printf("Pattern <%s> is NOT a Substring\n", str); } // driver program to test above functions int main(int argc, char* argv[]) { strcpy(text, "THIS IS A TEST TEXT\$"); buildSuffixTree(); checkForSubString("TEST"); checkForSubString("A"); checkForSubString(" "); checkForSubString("IS A"); checkForSubString(" IS A "); checkForSubString("TEST1"); checkForSubString("THIS IS GOOD"); checkForSubString("TES"); checkForSubString("TESA"); checkForSubString("ISB"); // Free the dynamically allocated memory freeSuffixTreeByPostOrder(root); return 0; } ``` Java ```class SuffixTreeNode { SuffixTreeNode[] children; SuffixTreeNode suffixLink; int start; int[] end; int suffixIndex; public SuffixTreeNode() { this.children = new SuffixTreeNode[256]; this.suffixLink = null; this.start = 0; this.end = null; this.suffixIndex = -1; } } public class SuffixTree { static final int MAX_CHAR = 256; static String text = ""; static SuffixTreeNode root = null; static SuffixTreeNode lastNewNode = null; static SuffixTreeNode activeNode = null; static int activeEdge = -1; static int activeLength = 0; static int remainingSuffixCount = 0; static int leafEnd = -1; static int[] rootEnd = null; static int[] splitEnd = null; static int size = -1; public static SuffixTreeNode newNode(int start, int[] end) { SuffixTreeNode node = new SuffixTreeNode(); node.start = start; node.end = end; node.suffixLink = root; node.suffixIndex = -1; return node; } public static int edgeLength(SuffixTreeNode n) { return (n == root) ? 0 : n.end[0] - n.start + 1; } public static boolean walkDown(SuffixTreeNode currNode) { if (activeLength >= edgeLength(currNode)) { activeEdge += edgeLength(currNode); activeLength -= edgeLength(currNode); activeNode = currNode; return true; } return false; } public static void extendSuffixTree(int pos) { leafEnd = pos; remainingSuffixCount++; lastNewNode = null; while (remainingSuffixCount > 0) { if (activeLength == 0) { activeEdge = pos; } if (activeNode.children[text.charAt(activeEdge)] == null) { activeNode.children[text.charAt(activeEdge)] = newNode(pos, new int[] { leafEnd }); if (lastNewNode != null) { lastNewNode.suffixLink = activeNode; lastNewNode = null; } } else { SuffixTreeNode next = activeNode.children[text.charAt( activeEdge)]; if (walkDown(next)) { continue; } int start = next.start; int end = next.end[0]; if (text.charAt(start + activeLength) == text.charAt(pos)) { if (lastNewNode != null && activeNode != root) { lastNewNode.suffixLink = activeNode; lastNewNode = null; } activeLength++; break; } splitEnd = new int[] { start + activeLength - 1 }; SuffixTreeNode split = newNode(next.start, splitEnd); activeNode.children[text.charAt(activeEdge)] = split; split.children[text.charAt(pos)] = newNode(pos, new int[] { leafEnd }); next.start += activeLength; split.children[text.charAt(next.start)] = next; if (lastNewNode != null) { lastNewNode.suffixLink = split; } lastNewNode = split; } remainingSuffixCount--; if (activeNode == root && activeLength > 0) { activeLength--; activeEdge = pos - remainingSuffixCount + 1; } else if (activeNode != root) { activeNode = activeNode.suffixLink; } } } public static void setSuffixIndexByDFS(SuffixTreeNode n, int labelHeight) { if (n == null) return; if (n.start != -1) { // Uncomment the following line to print suffix // tree print(n.start, n.end[0]); } int leaf = 1; for (int i = 0; i < MAX_CHAR; i++) { if (n.children[i] != null) { // Uncomment the following two lines to // print suffix index if (leaf == 1 && // n.start != -1) // System.out.print(" [" + n.suffixIndex // + "]"); leaf = 0; setSuffixIndexByDFS( n.children[i], labelHeight + edgeLength(n.children[i])); } } if (leaf == 1) { n.suffixIndex = size - labelHeight; // Uncomment the following line to print suffix // index System.out.print(" [" + n.suffixIndex + // "]"); } } public static void freeSuffixTreeByPostOrder(SuffixTreeNode n) { if (n == null) return; for (int i = 0; i < MAX_CHAR; i++) { if (n.children[i] != null) { freeSuffixTreeByPostOrder(n.children[i]); } } if (n.suffixIndex == -1) { n.end = null; } } public static void buildSuffixTree() { size = text.length(); rootEnd = new int[] { -1 }; root = newNode(-1, rootEnd); activeNode = root; for (int i = 0; i < size; i++) { extendSuffixTree(i); } int labelHeight = 0; setSuffixIndexByDFS(root, labelHeight); } public static int traverseEdge(String str, int idx, int start, int end) { int k = 0; for (k = start; k <= end && idx < str.length(); k++, idx++) { if (text.charAt(k) != str.charAt(idx)) { return -1; } } return (idx == str.length()) ? 1 : 0; } public static int doTraversal(SuffixTreeNode n, String str, int idx) { if (n == null) { return -1; } int res = -1; if (n.start != -1) { res = traverseEdge(str, idx, n.start, n.end[0]); if (res != 0) { return res; } } idx += edgeLength(n); if (n.children[str.charAt(idx)] != null) { return doTraversal(n.children[str.charAt(idx)], str, idx); } else { return -1; } } public static void checkForSubstring(String str) { int res = doTraversal(root, str, 0); if (res == 1) { System.out.println("Pattern <" + str + "> is a Substring"); } else { System.out.println("Pattern <" + str + "> is NOT a Substring"); } } // Driver program to test above functions public static void main(String[] args) { text = "THIS IS A TEST TEXT\$"; buildSuffixTree(); checkForSubstring("TEST"); checkForSubstring("A"); checkForSubstring(" "); checkForSubstring("IS A"); checkForSubstring(" IS A "); checkForSubstring("TEST1"); checkForSubstring("THIS IS GOOD"); checkForSubstring("TES"); checkForSubstring("TESA"); checkForSubstring("ISB"); // Free the dynamically allocated memory freeSuffixTreeByPostOrder(root); } } ``` Python ```class SuffixTreeNode: def __init__(self, start, end, root): # Dictionary to hold children (edges out of this node) self.children = {} # Suffix link which points to another internal node (initially None) self.suffix_link = root # Start and end indices of the edge label from parent node to this node self.start = start self.end = end # Suffix index for leaf nodes (initially set to -1) self.suffix_index = -1 def edge_length(self, current_pos): # Calculate edge length; use current_pos if it's a leaf (end is a reference to leafEnd) return self.end if isinstance(self.end, int) else current_pos - self.start + 1 class SuffixTree: def __init__(self, text): self.text = text self.root = SuffixTreeNode(None, None, None) self.root.suffix_link = self.root self.last_new_node = None self.active_node = self.root self.active_edge = 0 self.active_length = 0 self.remaining_suffix_count = 0 self.leaf_end = -1 self.size = len(text) self.build_suffix_tree() def build_suffix_tree(self): # Main function to build the suffix tree for the given text for i in range(self.size): self.extend_suffix_tree(i) def extend_suffix_tree(self, pos): # Rule 1 extension: Every suffix extension extends the leaf edges self.leaf_end = pos # Increment the count of suffixes we need to add self.remaining_suffix_count += 1 # Active node handling self.last_new_node = None while self.remaining_suffix_count > 0: if self.active_length == 0: self.active_edge = pos # APCFALZ next_char = self.text[self.active_edge] if self.active_edge < len( self.text) else None # Check if there is an outgoing edge starting with the active edge character if next_char not in self.active_node.children: # Rule 2 extension: Create a new leaf node self.active_node.children[next_char] = SuffixTreeNode( pos, self.leaf_end, self.root) if self.last_new_node is not None: self.last_new_node.suffix_link = self.active_node self.last_new_node = None else: next_node = self.active_node.children[next_char] # Walk down the tree if active length is longer than current edge length if self.active_length >= next_node.edge_length(pos): self.active_edge += next_node.edge_length(pos) self.active_length -= next_node.edge_length(pos) self.active_node = next_node continue # Rule 3 extension: Current character is already on the edge if self.text[next_node.start + self.active_length] == self.text[pos]: if self.last_new_node is not None and self.active_node != self.root: self.last_new_node.suffix_link = self.active_node self.active_length += 1 break # Rule 2 extension again: Creating a new internal node split_end = next_node.start + self.active_length - 1 split = SuffixTreeNode(next_node.start, split_end, self.root) self.active_node.children[next_char] = split split.children[self.text[pos]] = SuffixTreeNode( pos, self.leaf_end, self.root) next_node.start += self.active_length split.children[self.text[next_node.start]] = next_node if self.last_new_node is not None: self.last_new_node.suffix_link = split self.last_new_node = split # One suffix less to add self.remaining_suffix_count -= 1 if self.active_node == self.root and self.active_length > 0: self.active_length -= 1 self.active_edge = pos - self.remaining_suffix_count + 1 elif self.active_node != self.root: self.active_node = self.active_node.suffix_link def _do_traversal(self, node, string, idx): if node.start is not None: # Traverse edge character by character edge_len = node.edge_length(len(self.text) - 1) if self.text[node.start:node.start + edge_len] != string[idx:idx + edge_len]: return False idx += edge_len if idx == len(string): return True next_char = string[idx] if next_char in node.children: return self._do_traversal(node.children[next_char], string, idx) return False def check_substring(self, string): # Function to check if the string is a substring if self._do_traversal(self.root, string, 0): print(f"Pattern <{string}> is a Substring") else: print(f"Pattern <{string}> is NOT a Substring") # Driver code def main(): st = SuffixTree("THIS IS A TEST TEXT\$") queries = ["TEST", "A", " ", "IS A", " IS A ", "TEST1", "THIS IS GOOD", "TES", "TESA", "ISB"] for query in queries: st.check_substring(query) if __name__ == "__main__": main() ``` Javascript ```class SuffixTreeNode { constructor() { this.children = new Array(256).fill(null); this.suffixLink = null; this.start = 0; this.end = null; this.suffixIndex = -1; } } const MAX_CHAR = 256; let text = ""; let root = null; let lastNewNode = null; let activeNode = null; let activeEdge = -1; let activeLength = 0; let remainingSuffixCount = 0; let leafEnd = -1; let rootEnd = null; let splitEnd = null; let size = -1; function newNode(start, end) { const node = new SuffixTreeNode(); node.start = start; node.end = end; node.suffixLink = root; node.suffixIndex = -1; return node; } function edgeLength(n) { return (n === root) ? 0 : n.end[0] - n.start + 1; } function walkDown(currNode) { if (activeLength >= edgeLength(currNode)) { activeEdge += edgeLength(currNode); activeLength -= edgeLength(currNode); activeNode = currNode; return true; } return false; } function extendSuffixTree(pos) { leafEnd = pos; remainingSuffixCount++; lastNewNode = null; while (remainingSuffixCount > 0) { if (activeLength === 0) { activeEdge = pos; } if (!activeNode.children[text[activeEdge].charCodeAt(0)]) { activeNode.children[text[activeEdge].charCodeAt(0)] = newNode(pos, [leafEnd]); if (lastNewNode) { lastNewNode.suffixLink = activeNode; lastNewNode = null; } } else { const next = activeNode.children[text[activeEdge].charCodeAt(0)]; if (walkDown(next)) { continue; } const start = next.start; const end = next.end[0]; if (text[start + activeLength] === text[pos]) { if (lastNewNode && activeNode !== root) { lastNewNode.suffixLink = activeNode; lastNewNode = null; } activeLength++; break; } splitEnd = [start + activeLength - 1]; const split = newNode(next.start, splitEnd); activeNode.children[text[activeEdge].charCodeAt(0)] = split; split.children[text[pos].charCodeAt(0)] = newNode(pos, [leafEnd]); next.start += activeLength; split.children[text[next.start].charCodeAt(0)] = next; if (lastNewNode) { lastNewNode.suffixLink = split; } lastNewNode = split; } remainingSuffixCount--; if (activeNode === root && activeLength > 0) { activeLength--; activeEdge = pos - remainingSuffixCount + 1; } else if (activeNode !== root) { activeNode = activeNode.suffixLink; } } } function setSuffixIndexByDFS(n, labelHeight) { if (!n) return; if (n.start !== -1) { // Uncomment the following line to print suffix tree // print(n.start, n.end[0]); } let leaf = 1; for (let i = 0; i < MAX_CHAR; i++) { if (n.children[i]) { // Uncomment the following two lines to print suffix index // if (leaf === 1 && n.start !== -1) // console.log(" [" + n.suffixIndex + "]"); leaf = 0; setSuffixIndexByDFS(n.children[i], labelHeight + edgeLength(n.children[i])); } } if (leaf === 1) { n.suffixIndex = size - labelHeight; // Uncomment the following line to print suffix index // console.log(" [" + n.suffixIndex + "]"); } } function freeSuffixTreeByPostOrder(n) { if (!n) return; for (let i = 0; i < MAX_CHAR; i++) { if (n.children[i]) { freeSuffixTreeByPostOrder(n.children[i]); } } if (n.suffixIndex === -1) { n.end = null; } } function buildSuffixTree() { size = text.length; rootEnd = [-1]; root = newNode(-1, rootEnd); activeNode = root; for (let i = 0; i < size; i++) { extendSuffixTree(i); } let labelHeight = 0; setSuffixIndexByDFS(root, labelHeight); } function traverseEdge(str, idx, start, end) { let k = 0; for (k = start; k <= end && str[idx] !== undefined; k++, idx++) { if (text[k] !== str[idx]) { return -1; } } return (str[idx] === undefined) ? 1 : 0; } function doTraversal(n, str, idx) { if (!n) { return -1; } let res = -1; if (n.start !== -1) { res = traverseEdge(str, idx, n.start, n.end[0]); if (res !== 0) { return res; } } idx += edgeLength(n); if (n.children[text[idx].charCodeAt(0)]) { return doTraversal(n.children[text[idx].charCodeAt(0)], str, idx); } else { return -1; } } function checkForSubString(str) { const res = doTraversal(root, str, 0); if (res === 1) { console.log("Pattern <" + str + "> is a Substring"); } else { console.log("Pattern <" + str + "> is NOT a Substring"); } } // Driver program to test above functions function main() { text = "THIS IS A TEST TEXT\$"; buildSuffixTree(); checkForSubString("TEST"); checkForSubString("A"); checkForSubString(" "); checkForSubString("IS A"); checkForSubString(" IS A "); checkForSubString("TEST1"); checkForSubString("THIS IS GOOD"); checkForSubString("TES"); checkForSubString("TESA"); checkForSubString("ISB"); // Free the dynamically allocated memory freeSuffixTreeByPostOrder(root); } main(); ```

Output:

`Pattern <TEST> is a SubstringPattern <A> is a SubstringPattern < > is a SubstringPattern <IS A> is a SubstringPattern < IS A > is a SubstringPattern <TEST1> is NOT a SubstringPattern <THIS IS GOOD> is NOT a SubstringPattern <TES> is a SubstringPattern <TESA> is NOT a SubstringPattern <ISB> is NOT a Substring`

Ukkonen’s Suffix Tree Construction takes O(N) time and space to build suffix tree for a string of length N and after that, traversal for substring check takes O(M) for a pattern of length M.
With a slight modification in the traversal algorithm discussed here, we can answer the following:

1. Find all occurrences of a given pattern P present in text T.
2. How to check if a pattern is prefix of a text?
3. How to check if a pattern is suffix of a text?

We have published following more articles on suffix tree applications:

Previous
Next