Ternary Search Tree

Introduction:

Ternary Search Tree is a trie data structure commonly used as a low-memory alternative to trie in various applications such as spell check and looking for nearby neighbors.

Ternary Search Trees (TST) stand as a sophisticated and efficient data structure that combines the best of binary search trees and trie structures. Introduced by Jon Bentley and Robert Sedgewick in their seminal paper "Ternary Search Trees" in 1998.

To comprehend the ternary search tree, we must first grasp the concept of the trie. A trie, also known as a digital tree, radix tree, or prefix tree, is a type of search tree, an ordered tree data structure used to hold a dynamic set or associative array using strings as keys.

Structure of Ternary Search Trees:

A Ternary Search Tree is essentially a type of trie where each node has three children instead of the traditional two in binary trees. The nodes are designed to store individual characters from keys in a sorted order. This unique structure enables efficient searching, insertion, and deletion operations.

1. Node Structure:

Key: Represents the character associated with the node.
Data: Holds the value associated with the character.
Left, Middle, and Right Pointers: Point to the three children nodes.

2. Balanced Structure:

TSTs inherently maintain a balanced structure, ensuring efficient searching and space optimization.
The middle child node helps in balancing the tree, preventing skewed structures commonly found in binary trees.

Let's consider an example to illustrate the structure of a Ternary Search Tree:

In this example, the TST represents the strings "CAT," "ME," "MET," "MEX," "METAL," and "METEOR." Each node in the tree corresponds to a character in these strings.

Representation of Ternary Search Trees:

In the trie (standard) data structure, each node contains 26 pointers for its children, but in a ternary search tree, each node contains only 3 pointers:

The left pointer points to the node whose value is lower than the current node's value.
The equal pointer leads to a node whose value is the same as the current node's value.
The right pointer leads to the node whose value exceeds the current node's value.

Aside from the three-pointers mentioned above, each node contains a field for indicating data (character in the case of a dictionary) and a field for indicating the end of a string.

So, it's similar to BST, which saves data in a specific order. On the other hand, data in a ternary search tree is dispersed among the nodes. For example, you required the four nodes to store the term "Bird".

One advantage of ternary search trees over tries is that ternary search trees take up less space (only three-pointers per node compared to 26 in standard tries). In addition, ternary search trees may be utilized in any situation where a hash table is used to hold strings.

Tries are appropriate when there is the correct distribution of words throughout the alphabets, allowing for the most effective use of space. Ternary search trees are preferable when the strings to be stored all have the same prefix; ternary search trees are the most economical in terms of space.

Operations on Ternary Search Trees:

1. Insertion:

The insertion operation involves traversing the tree, creating new nodes as needed to accommodate the characters of the key.

The process ensures that each node is inserted in a sorted order, maintaining the inherent structure of the TST.

2. Search:

The search operation involves traversing the tree based on the characters of the key.

At each step, the algorithm compares the current character with the character stored in the current node.

The search is successful when the entire key is traversed, and the corresponding data is found.

3. Deletion:

Deletion in TSTs is a complex operation involving recursive traversal and restructuring to maintain the tree's balance.

Care must be taken to handle various cases, such as nodes with one, two, or three children.

Properties:

Trie-Like Structure: TSTs share similarities with tries, where each node represents a character of a string. However, unlike tries, TSTs do not have a node for every character. Instead, a TST node contains only a single character and has pointers to nodes with the next character in the string.
Binary Search Tree Characteristics: Each node in a TST follows the binary search tree property, where the nodes in the left subtree have values less than the current node, and nodes in the right subtree have values greater than the current node.
Efficient Search: TSTs efficiently support prefix search, substring search, and exact match search. The tree structure allows for rapid pruning of irrelevant subtrees during search operations.

Implementation:

#include <iostream>
#include <string>
class TSTNode {
public:
    char data;
    bool isEnd;
    TSTNode* left;
    TSTNode* middle;
    TSTNode* right;
    TSTNode(char val) : data(val), isEnd(false), left(nullptr), middle(nullptr), right(nullptr) {}
};
class TernarySearchTree {
private:
    TSTNode* root;
    // Helper function for insertion
    TSTNode* insert(TSTNode* node, const std::string& key, size_t index);
    // Helper function for search
    bool search(TSTNode* node, const std::string& key, size_t index);
public:
    TernarySearchTree() : root(nullptr) {}
    // Public interface for insertion
    void insert(const std::string& key);
    // Public interface for search
    bool search(const std::string& key);
};
// Implementation of insertion
TSTNode* TernarySearchTree::insert(TSTNode* node, const std::string& key, size_t index) {
    char currentChar = key[index];
    if (!node) {
        node = new TSTNode(currentChar);
    }
    if (currentChar < node->data) {
        node->left = insert(node->left, key, index);
    } else if (currentChar == node->data) {
        if (index < key.length() - 1) {
            node->middle = insert(node->middle, key, index + 1);
        } else {
            node->isEnd = true;
        }
    } else {
        node->right = insert(node->right, key, index);
    }
    return node;
}
// Public interface for insertion
void TernarySearchTree::insert(const std::string& key) {
    root = insert(root, key, 0);
}
// Implementation of search
bool TernarySearchTree::search(TSTNode* node, const std::string& key, size_t index) {
    if (!node) {
        return false;
    }
    char currentChar = key[index];
    if (currentChar < node->data) {
        return search(node->left, key, index);
    } else if (currentChar == node->data) {
        if (index == key.length() - 1) {
            return node->isEnd;
        } else {
            return search(node->middle, key, index + 1);
        }
    } else {
        return search(node->right, key, index);
    }
}
// Public interface for search
bool TernarySearchTree::search(const std::string& key) {
    return search(root, key, 0);
}
// Example usage
int main() {
    TernarySearchTree tst;
    tst.insert("apple");
    tst.insert("banana");
    tst.insert("orange");
    std::cout << "Search for 'apple': " << (tst.search("apple") ? "Found" : "Not found") << std::endl;
    std::cout << "Search for 'grape': " << (tst.search("grape") ? "Found" : "Not found") << std::endl;
    return 0;
}

Explanation:

The program defines a class called TSTNode, representing a node in the Ternary Search Tree.
Each node contains a character (data), a boolean flag (isEnd) indicating whether the node represents the end of a word, and three pointers (left, middle, and right) pointing to the left, middle, and right child nodes, respectively.
The constructor initializes the node with the given character.
The program also defines a class named TernarySearchTree, which encapsulates the TST It includes a private member root representing the root of the TST.
The Ternary Search Tree supports insertion through a recursive helper function insert. This function takes a node, a key (string to be inserted), and the current index in the key.
It recursively traverses the tree based on the characters of the key, creating new nodes as needed, until it reaches the end of the key. The insert function is used internally and is not exposed in the public interface.
The TST provides a search operation through a recursive helper function search. This function checks if the characters of the key match the tree nodes and continues the search until it reaches the end of the key, verifying if the last node is marked as the end of a word.
The public search method, search(const std::string& key), serves as an interface for the user and initiates the search process by calling the private search function with the root and the initial index.
The public insertion method, insert(const std::string& key), serves as an interface and starts the insertion process by calling the private insert function with the root and the initial index.
In the main function, an instance of TernarySearchTree is created, and three words ("apple," "banana," and "orange") are inserted into the TST using the insert method.
Then, the program searches for the words "apple" and "grape" using the search method and prints whether each word is found or not.

Program Output:

Java Code

Now let's write a Java program to implement a ternary search tree.

/** 
 ** A sample Java program to implement Ternary Search Tree 
 **/  
import java.util.Scanner;  
import java.util.ArrayList;  
/** class TSTNode **/  
class TSTNode  
{  
    char data;  
    boolean isEnd;  
    TSTNode left, middle, right;  
    /** Constructor **/  
    public TSTNode(char data)  
    {  
        this.data = data;  
        this.isEnd = false;  
        this.left = null;  
        this.middle = null;  
        this.right = null;  
    }          
}   
/** class TernarySearchTree **/  
class TernarySearchTree  
{  
    private TSTNode root;  
    private ArrayList<String> al;  
   
    /** Constructor **/  
    public TernarySearchTree()  
    {  
        root = null;  
    }  
    /** function to check if empty **/  
    public boolean isEmpty()  
    {  
        return root == null;  
    }  
    /** function to clear **/  
    public void makeEmpty()  
    {  
        root = null;  
    }  
    /** function to insert for a word **/  
    public void insert(String word)  
    {  
        root = insert(root, word.toCharArray(), 0);  
    }  
    /** function to insert for a word **/  
    public TSTNode insert(TSTNode r, char[] word, int ptr)  
    {  
        if (r == null)  
            r = new TSTNode(word[ptr]);  
        if (word[ptr] < r.data)  
            r.left = insert(r.left, word, ptr);  
        else if (word[ptr] > r.data)  
            r.right = insert(r.right, word, ptr);  
        else  
        {  
            if (ptr + 1 < word.length)  
                r.middle = insert(r.middle, word, ptr + 1);  
            else  
                r.isEnd = true;  
        }  
        return r;  
    }   
    /** function to delete a word **/  
    public void delete(String word)  
    {  
        delete(root, word.toCharArray(), 0);  
    }  
    /** function to delete a word **/  
    private void delete(TSTNode r, char[] word, int ptr)  
    {  
        if (r == null)  
            return;   
        if (word[ptr] < r.data)  
            delete(r.left, word, ptr);  
        else if (word[ptr] > r.data)  
            delete(r.right, word, ptr);  
        else  
        {  
            /** to delete a word just make isEnd false **/  
            if (r.isEnd && ptr == word.length - 1)  
                r.isEnd = false;  
            else if (ptr + 1 < word.length)  
                delete(r.middle, word, ptr + 1);  
        }          
    }   
    /** function to search for a word **/  
    public boolean search(String word)  
    {  
        return search(root, word.toCharArray(), 0);  
    }  
    /** function to search for a word **/  
    private boolean search(TSTNode r, char[] word, int ptr)  
    {  
        if (r == null)  
            return false;  
        if (word[ptr] < r.data)  
            return search(r.left, word, ptr);  
        else if (word[ptr] > r.data)  
            return search(r.right, word, ptr);  
        else  
        {  
            if (r.isEnd && ptr == word.length - 1)  
                return true;  
            else if (ptr == word.length - 1)  
                return false;  
            else  
                return search(r.middle, word, ptr + 1);  
        }          
    }  
    /** function to print tree **/  
    public String toString()  
    {  
        al = new ArrayList<String>();  
        traverse(root, "");  
        return "\nTernary Search Tree : "+ al;  
    }  
    /** function to traverse tree **/  
    private void traverse(TSTNode r, String str)  
    {  
        if (r != null)  
        {  
            traverse(r.left, str);  
            str = str + r.data;  
            if (r.isEnd)  
                al.add(str);   
            traverse(r.middle, str);  
            str = str.substring(0, str.length() - 1);   
            traverse(r.right, str);  
        }  
    }  
}  
/** class TernarySearchTree **/  
public class TernarySearchTreeTest  
{  
    public static void main(String[] args)  
    {  
        Scanner scan = new Scanner(System.in);   
        /* Creating object of TernarySearchTree */  
        TernarySearchTree tst = new TernarySearchTree();   
        System.out.println("Ternary Search Tree Test\n");   
        char ch;  
        /*  Perform tree operations  */  
        do      
        {  
            System.out.println("\nSelect one of the operation for Ternary Search Tree::");  
            System.out.println("1. To insert a new word in the Ternary Search Tree.");  
            System.out.println("2. To search an already existing word in the Ternary Search Tree.");  
            System.out.println("3. To delete a word from the Ternary Search Tree");  
            System.out.println("4. To check if the Ternary Tree is empty.");  
            System.out.println("5. To make the Ternary Search Tree empty.");  
            int choice = scan.nextInt();              
            switch (choice)  
            {  
            case 1 :   
                System.out.println("Enter word to insert");  
                tst.insert( scan.next() );                       
                break;                            
            case 2 :   
                System.out.println("Enter word to search");  
                System.out.println("Search result : "+ tst.search( scan.next() ));  
                break;   
            case 3 :   
                System.out.println("Enter word to delete");  
                tst.delete( scan.next() );                       
                break;   
            case 4 :   
                System.out.println("Empty Status : "+ tst.isEmpty() );                  
                break;      
            case 5 :   
                System.out.println("Ternary Search Tree cleared");   
                tst.makeEmpty();                 
                break;                                          
            default :   
                System.out.println("Wrong Entry \n ");  
                break;     
            }  
            System.out.println(tst);   
            System.out.println("\nDo you want to continue (Type y or n) \n");  
            ch = scan.next().charAt(0);                          
        } while (ch == 'Y'|| ch == 'y');          
    }  
}  

Output

The above Java code gives the following output.

Ternary Search Tree Test
Select one of the operations for Ternary Search Tree::
1. To insert a new word in the Ternary Search Tree.
2. To search an already existing word in the Ternary Search Tree.
3. To delete a word from the Ternary Search Tree
4. To check if the Ternary Tree is empty.
5. To make the Ternary Search Tree empty.
1
Enter the word to insert
red
Ternary Search Tree : [red]
Do you want to continue (Type y or n)
y
Select one of the operations for Ternary Search Tree::
1. To insert a new word in the Ternary Search Tree.
2. To search an already existing word in the Ternary Search Tree.
3. To delete a word from the Ternary Search Tree
4. To check if the Ternary Tree is empty.
5. To make the Ternary Search Tree empty.
1
Enter the word to insert
blur e
Ternary Search Tree : [blue, red]
Do you want to continue (Type y or n)
y
Select one of the operations for Ternary Search Tree::
1. To insert a new word in the Ternary Search Tree.
2. To search an already existing word in the Ternary Search Tree.
3. To delete a word from the Ternary Search Tree
4. To check if the Ternary Tree is empty.
5. To make the Ternary Search Tree empty.
1
Enter the word to insert
green
Ternary Search Tree : [blue, green, red]
Do you want to continue (Type y or n)
y
Select one of the operations for Ternary Search Tree::
1. To insert a new word in the Ternary Search Tree.
2. To search an already existing word in the Ternary Search Tree.
3. To delete a word from the Ternary Search Tree
4. To check if the Ternary Tree is empty.
5. To make the Ternary Search Tree empty.
1
Enter the word to insert
yellow
Ternary Search Tree : [blue, green, red, yellow]
Do you want to continue (Type y or n)
y
Select one of the operations for Ternary Search Tree::
1. To insert a new word in the Ternary Search Tree.
2. To search an already existing word in the Ternary Search Tree.
3. To delete a word from the Ternary Search Tree
4. To check if the Ternary Tree is empty.
5. To make the Ternary Search Tree empty.
1
Enter the word to insert
pink
Ternary Search Tree : [blue, green, pink, red, yellow]
Do you want to continue (Type y or n)
y
Select one of the operations for Ternary Search Tree::
1. To insert a new word in the Ternary Search Tree.
2. To search an already existing word in the Ternary Search Tree.
3. To delete a word from the Ternary Search Tree
4. To check if the Ternary Tree is empty.
5. To make the Ternary Search Tree empty.
1
Enter the word to insert
black
Ternary Search Tree : [black, blue, green, pink, red, yellow]
Do you want to continue (Type y or n)
y
Select one of the operations for Ternary Search Tree::
1. To insert a new word in the Ternary Search Tree.
2. To search an already existing word in the Ternary Search Tree.
3. To delete a word from the Ternary Search Tree
4. To check if the Ternary Tree is empty.
5. To make the Ternary Search Tree empty.
1
Enter the word to insert
grey
Ternary Search Tree : [black, blue, green, grey, pink, red, yellow]
Do you want to continue (Type y or n)
y
Select one of the operations for Ternary Search Tree::
1. To insert a new word in the Ternary Search Tree.
2. To search an already existing word in the Ternary Search Tree.
3. To delete a word from the Ternary Search Tree
4. To check if the Ternary Tree is empty.
5. To make the Ternary Search Tree empty.
1
Enter the word to insert
mustard
Ternary Search Tree : [black, blue, green, grey, mustard, pink, red, yellow]
Do you want to continue (Type y or n)
y
Select one of the operations for Ternary Search Tree::
1. To insert a new word in the Ternary Search Tree.
2. To search an already existing word in the Ternary Search Tree.
3. To delete a word from the Ternary Search Tree
4. To check if the Ternary Tree is empty.
5. To make the Ternary Search Tree empty.
1
Enter the word to insert
White
Ternary Search Tree : [White, black, blue, green, grey, mustard, pink, red, yellow]
Do you want to continue (Type y or n)
y
Select one of the operations for Ternary Search Tree::
1. To insert a new word in the Ternary Search Tree.
2. To search an already existing word in the Ternary Search Tree.
3. To delete a word from the Ternary Search Tree
4. To check if the Ternary Tree is empty.
5. To make the Ternary Search Tree empty.
1
Enter the word to insert
purple
Ternary Search Tree : [White, black, blue, green, grey, mustard, pink, purple, red, yellow]
Do you want to continue (Type y or n)
y
Select one of the operations for Ternary Search Tree::
1. To insert a new word in the Ternary Search Tree.
2. To search an already existing word in the Ternary Search Tree.
3. To delete a word from the Ternary Search Tree
4. To check if the Ternary Tree is empty.
5. To make the Ternary Search Tree empty.
2
Enter the word to search
black
Search result: true
Ternary Search Tree : [White, black, blue, green, grey, mustard, pink, purple, red, yellow]
Do you want to continue (Type y or n)
y
Select one of the operations for Ternary Search Tree::
1. To insert a new word in the Ternary Search Tree.
2. To search an already existing word in the Ternary Search Tree.
3. To delete a word from the Ternary Search Tree
4. To check if the Ternary Tree is empty.
5. To make the Ternary Search Tree empty.
3
Enter the word to delete
blue mustard
Ternary Search Tree : [White, black, blue, green, grey, pink, purple, red, yellow]
Do you want to continue (Type y or n)
y
Select one of the operations for Ternary Search Tree::
1. To insert a new word in the Ternary Search Tree.
2. To search an already existing word in the Ternary Search Tree.
3. To delete a word from the Ternary Search Tree
4. To check if the Ternary Tree is empty.
5. To make the Ternary Search Tree empty.
4
Empty Status: false
Ternary Search Tree : [White, black, blue, green, grey, pink, purple, red, yellow]
Do you want to continue (Type y or n)
y
Select one of the operations for Ternary Search Tree::
1. To insert a new word in the Ternary Search Tree.
2. To search an already existing word in the Ternary Search Tree.
3. To delete a word from the Ternary Search Tree
4. To check if the Ternary Tree is empty.
5. To make the Ternary Search Tree empty.
3
Enter the word to delete
black
Ternary Search Tree : [White, blue, green, grey, pink, purple, red, yellow]
Do you want to continue (Type y or n)
y
Select one of the operations for Ternary Search Tree::
1. To insert a new word in the Ternary Search Tree.
2. To search an already existing word in the Ternary Search Tree.
3. To delete a word from the Ternary Search Tree
4. To check if the Ternary Tree is empty.
5. To make the Ternary Search Tree empty.
5
Ternary Search Tree cleared
Ternary Search Tree : []
Do you want to continue (Type y or n)
y
Select one of the operations for Ternary Search Tree::
1. To insert a new word in the Ternary Search Tree.
2. To search an already existing word in the Ternary Search Tree.
3. To delete a word from the Ternary Search Tree
4. To check if the Ternary Search Tree is empty.
5. To make the Ternary Search Tree empty.
4
Empty Status: true
Ternary Search Tree : []
Do you want to continue (Type y or n)
n

In the above Java code, we have implemented the ternary search tree data structure and various functions like adding new data in the ternary search tree, deleting the existing data from the ternary search tree, to check whether the ternary search tree is empty or not, there is also one operation to empty the tree that will delete all the content within the ternary search tree and the traversal of the ternary search tree.

For all these operations of the ternary search tree, there are different functions written, and then according to the need of the operation on the ternary search tree data structure, those functions are called.

C++ Code

Let's write the C++ code for the ternary search tree.

/* 
 * C++ Program to implement Ternary Seach Tree
 */
#include <iostream>
#include <cstdlib>
#define MAX 50
using namespace std; 
/* 
 * Node Declaration
 */
struct Node
{
    char data;
    unsigned isEndOfString: 1;
    Node *left, *eq, *right;
};
/* 
 * create a new ternary search tree node
 */ 
Node* newNode(char data)
{
    Node* temp = new Node;
    temp->data = data;
    temp->isEndOfString = 0;
    temp->left = temp->eq = temp->right = NULL;
    return temp;
}
/* 
 * insert a new word in a Ternary Search Tree
 */ 
void insert(Node** root, char *word)
{
    if (!(*root))
        *root = newNode(*word);
    if ((*word) < (*root)->data)
        insert(&((*root)->left), word);
    else if ((*word) > (*root)->data)
        insert(&((*root)->right), word);
    else
    {
        if (*(word + 1))
            insert(&( (*root)->eq ), word + 1);
        else
            (*root)->isEndOfString = 1;
    }
}
/* 
 * traverse Utility function
 */  
void traverseTSTUtil(Node* root, char* buffer, int depth)
{
    if (root)
    {
        traverseTSTUtil(root->left, buffer, depth);
        buffer[depth] = root->data;
        if (root->isEndOfString)
        {
            buffer[depth + 1] = '\0';
            cout<<buffer<<endl;
        }
        traverseTSTUtil(root->eq, buffer, depth + 1);
        traverseTSTUtil(root->right, buffer, depth);
    }
}
/* 
 * traverse Ternary Search Tree
 */  
void traverseTST(Node* root)
{
    char buffer[MAX];
    traverseTSTUtil(root, buffer, 0);
}
/* 
 * search a given word in Ternary Search Tree
 */  
int searchTST(Node *root, char *word)
{
    if (!root)
        return 0;
    if (*word < (root)->data)
        return searchTST(root->left, word);
    else if (*word > (root)->data)
        return searchTST(root->right, word);
    else
    {
        if (*(word + 1) == '\0')
            return root->isEndOfString;
        return searchTST(root->eq, word+1);
    }
}
/* 
 * beginning of the Main function to call all the functions of the ternary search tree.
 */  
int main()
{
    Node *root = NULL;
    char s[100];
        char ch;
        /*  Perform tree operations  */
        do    
        {
            cout<<"\nSelect one of the operation for Ternary Search Tree::"<<endl;
            cout<<"1. To insert a new word in the Ternary Search Tree."<<endl;
            cout<<"2. To search an already exisitng word in the Ternary Search Tree."<<endl;
            cout<<"3. To Traverse the Ternary Search Tree."<<endl;             
            int choice;
            cin>>choice;            
            switch (choice)
            {
            case 1 : 
                cout<<"Enter word to insert"<<endl;
                cin>>s;
                insert(&root,s);                     
                break;                          
            case 2 : 
                cout<<"Enter word to search"<<endl;
                cin>>s;
                if (searchTST(root, s))
                    cout<<s<<" found in Ternary Search Tree"<<endl;
                else
                    cout<<s<<" not found in Ternary Search Tree"<<endl;
                break; 
            case 3 : 
                cout<<"Contents of the Ternary Search Tree are::"<<endl;
                traverseTST(root);
                break; 
            default : 
                cout<<"Wrong Entry \n ";
                break;   
            }
            cout<<"\nDo you want to continue (Type y or n) \n";
            cin>>ch;                        
        } while (ch == 'Y'|| ch == 'y');
return 0;
}

Output

The above C++ code gives the following output.

Select one of the operations for Ternary Search Tree::
1. To insert a new word in the Ternary Search Tree.
2. To search an already existing word in the Ternary Search Tree.
3. To Traverse the Ternary Search Tree.
1
Enter the word to insert
orange 
Do you want to continue (Type y or n) 
y
Select one of the operations for Ternary Search Tree::
1. To insert a new word in the Ternary Search Tree.
2. To search an already existing word in the Ternary Search Tree.
3. To Traverse the Ternary Search Tree.
1
Enter the word to insert
banana
Do you want to continue (Type y or n) 
y
Select one of the operations for Ternary Search Tree::
1. To insert a new word in the Ternary Search Tree.
2. To search an already existing word in the Ternary Search Tree.
3. To Traverse the Ternary Search Tree.
1
Enter the word to insert
grapes 
Do you want to continue (Type y or n) 
y
Select one of the operations for Ternary Search Tree::
1. To insert a new word in the Ternary Search Tree.
2. To search an already existing word in the Ternary Search Tree.
3. To Traverse the Ternary Search Tree.
1
Enter the word to insert
apple
Do you want to continue (Type y or n) 
y
Select one of the operations for Ternary Search Tree::
1. To insert a new word in the Ternary Search Tree.
2. To search an already existing word in the Ternary Search Tree.
3. To Traverse the Ternary Search Tree.
1
Enter the word to insert
watermelon
Do you want to continue (Type y or n) 
y
Select one of the operations for Ternary Search Tree::
1. To insert a new word in the Ternary Search Tree.
2. To search an already existing word in the Ternary Search Tree.
3. To Traverse the Ternary Search Tree.
1
Enter the word to insert
guava
Do you want to continue (Type y or n) 
y
Select one of the operations for Ternary Search Tree::
1. To insert a new word in the Ternary Search Tree.
2. To search an already existing word in the Ternary Search Tree.
3. To Traverse the Ternary Search Tree.
1
Enter the word to insert
Kiwi
Do you want to continue (Type y or n) 
y
Select one of the operations for Ternary Search Tree::
1. To insert a new word in the Ternary Search Tree.
2. To search an already existing word in the Ternary Search Tree.
3. To Traverse the Ternary Search Tree.
3
Contents of the Ternary Search Tree are::
Kiwi
apple
Banana
Watermelon
guava
grapes
orange
Do you want to continue (Type y or n) 
y
Select one of the operations for Ternary Search Tree::
1. To insert a new word in the Ternary Search Tree.
2. To search an already existing word in the Ternary Search Tree.
3. To Traverse the Ternary Search Tree.
2
Enter the word to search
Kiwi
Kiwi found in Ternary Search Tree
Do you want to continue (Type y or n) 
y
Select one of the operations for Ternary Search Tree::
1. To insert a new word in the Ternary Search Tree.
2. To search an already existing word in the Ternary Search Tree.
3. To Traverse the Ternary Search Tree.
2
Enter the word to search
mango
mango not found in Ternary Search Tree
Do you want to continue (Type y or n) 
n

In the above C++ code, we have implemented the ternary search tree data structure and various functions like adding new data, deleting the existing data, and the traversal of the ternary search tree. For all these operations of the ternary search tree, there are different functions written, and then according to the need of the operation on the ternary search tree data structure, those functions are called.