Ternary search tree
In computer science, a ternary search tree is a type of trie (sometimes called a prefix tree) where nodes are arranged in a manner similar to a binary search tree, but with up to three children rather than the binary tree's limit of two. Like other prefix trees, a ternary search tree can be used as an associative map structure with the ability for incremental string search. However, ternary search trees are more space efficient compared to standard prefix trees, at the cost of speed. Common applications for ternary search trees include spellchecking and autocompletion.
Ternary Search Tree (TST)  

Type  tree  
Time complexity in big O notation  

Description
Each node of a ternary search tree stores a single character, an object (or a pointer to an object depending on implementation), and pointers to its three children conventionally named equal kid, lo kid and hi kid, which can also be referred respectively as middle (child), lower (child) and higher (child).[1] A node may also have a pointer to its parent node as well as an indicator as to whether or not the node marks the end of a word.[2] The lo kid pointer must point to a node whose character value is less than the current node. The hi kid pointer must point to a node whose character is greater than the current node.[1] The equal kid points to the next character in the word. The figure below shows a ternary search tree with the strings "cute","cup","at","as","he","us" and "i":
c /  \ a u h    \ t t e u / /  /  s p e i s
As with other trie data structures, each node in a ternary search tree represents a prefix of the stored strings. All strings in the middle subtree of a node start with that prefix.
Operations
Insertion
Inserting a value into a ternary search can be defined recursively much as lookups are defined. This recursive method is continually called on nodes of the tree given a key which gets progressively shorter by pruning characters off the front of the key. If this method reaches a node that has not been created, it creates the node and assigns it the character value of the first character in the key. Whether a new node is created or not, the method checks to see if the first character in the string is greater than or less than the character value in the node and makes a recursive call on the appropriate node as in the lookup operation. If, however, the key's first character is equal to the node's value then the insertion procedure is called on the equal kid and the key's first character is pruned away.[1] Like binary search trees and other data structures, ternary search trees can become degenerate depending on the order of the keys.[3] Inserting keys in alphabetical order is one way to attain the worst possible degenerate tree.[1] Inserting the keys in random order often produces a wellbalanced tree.[1]
Search
To look up a particular node or the data associated with a node, a string key is needed. A lookup procedure begins by checking the root node of the tree and determining which of the following conditions has occurred. If the first character of the string is less than the character in the root node, a recursive lookup can be called on the tree whose root is the lo kid of the current root. Similarly, if the first character is greater than the current node in the tree, then a recursive call can be made to the tree whose root is the hi kid of the current node.[1] As a final case, if the first character of the string is equal to the character of the current node then the function returns the node if there are no more characters in the key. If there are more characters in the key then the first character of the key must be removed and a recursive call is made given the equal kid node and the modified key.[1] This can also be written in a nonrecursive way by using a pointer to the current node and a pointer to the current character of the key.[1]
Pseudocode
function search(string query) { if is_empty(query) { return false; } var node p := root; var int idx := 0; while p is not null { if query[idx] < p.splitchar { p := p.left; } else if query[idx] > p.splitchar { p := p.right; } else { if idx == last_valid_index(query) { return true; } idx := idx + 1; p := p.center; } } return false; }
Deletion
Traversal
Partialmatch searching
Nearneighbor searching
Running time
The running time of ternary search trees varies significantly with the input. Ternary search trees run best when given several similar strings, especially when those strings share a common prefix. Alternatively, ternary search trees are effective when storing a large number of relatively short strings (such as words in a dictionary).[1] Running times for ternary search trees are similar to binary search trees, in that they typically run in logarithmic time, but can run in linear time in the degenerate (worst) case.
Time complexities for ternary search tree operations:[1]
Averagecase running time  Worstcase running time  

Lookup  O(log n)  O(n) 
Insertion  O(log n)  O(n) 
Delete  O(log n)  O(n) 
Comparison to other data structures
Tries
While being slower than other prefix trees, ternary search trees can be better suited for larger data sets due to their spaceefficiency.[1]
Hash maps
Hashtables can also be used in place of ternary search trees for mapping strings to values. However, hash maps also frequently use more memory than ternary search trees (but not as much as tries). Additionally, hash maps are typically slower at reporting a string that is not in the same data structure, because it must compare the entire string rather than just the first few characters. There is some evidence that shows ternary search trees running faster than hash maps.[1] Additionally, hash maps do not allow for many of the uses of ternary search trees, such as nearneighbor lookups.
DAFSAs (deterministic acyclic finite state automaton)
If storing dictionary words is all that is required (i.e., storage of information auxiliary to each word is not required), a minimal deterministic acyclic finite state automaton (DAFSA) would use less space than a trie or a ternary search tree. This is because a DAFSA can compress identical branches from the trie which correspond to the same suffixes (or parts) of different words being stored.
Uses
Ternary search trees can be used to solve many problems in which a large number of strings must be stored and retrieved in an arbitrary order. Some of the most common or most useful of these are below:
 Anytime a trie could be used but a less memoryconsuming structure is preferred.[1]
 A quick and spacesaving data structure for mapping strings to other data.[3]
 To implement autocompletion.[2]
 As a spell check.[4]
 Nearneighbor searching (of which spellchecking is a special case).[1]
 As a database especially when indexing by several nonkey fields is desirable.[4]
 In place of a hash table.[4]
References
 "Ternary Search Trees". Dr. Dobb's.
 Ostrovsky, Igor. "Efficient autocomplete with a ternary search tree".
 Wrobel, Lukasz. "Ternary Search Tree".
 Flint, Wally. "Plant your data in a ternary search tree".
External links
 Ternary Search Trees page with papers (by Jon Bentley and Robert Sedgewick) about ternary search trees and algorithms for "sorting and searching strings"
 Ternary Search Tries – a video by Robert Sedgewick
 TST.java.html Implementation in Java of a TST by Robert Sedgewick and Kevin Wayne