The core of implementing the Trie tree is to design the node structure and correctly handle the insertion and search logic. 1. The TrieNode class contains a character array or hash table to indicate whether the child nodes and markers are endings; 2. Insert operation to build a character-by-character path and mark the end of the word at the end; 3. The search operation is divided into two situations: complete word matching and prefix matching; 4. It is necessary to consider edge cases such as empty strings, case sensitivity, memory optimization, etc. and improvement directions.

Implementing a trie (prefix tree) in Java is a common task when dealing with problems related to string searching, autocomplete features, or dictionary implementations. The core idea behind a trie is that each node represents a character, and paths from the root to nodes represent possible strings.

Basic Structure of a Trie Node

To start building a trie, you first need a TrieNode class. This class will represent each character in the trie and contain:

• An array or map of children (dependent on whether you're using a fixed alphabet like lowercase English letters or a more general approach).
• A flag to indicate if the node marks the end of a word.

 class TrieNode {
    private TrieNode[] children;
    private boolean isEndOfWord;
    private static final int ALPHABET_SIZE = 26; // assuming only lowercase English letters

    public TrieNode() {
        children = new TrieNode[ALPHABET_SIZE];
        isEndOfWord = false;
    }

    public TrieNode getChild(char ch) {
        return children[ch - 'a'];
    }

    public void setChild(char ch, TrieNode node) {
        children[ch - 'a'] = node;
    }

    public boolean isEndOfWord() {
        return isEndOfWord;
    }

    public void setEndOfWord(boolean endOfWord) {
        isEndOfWord = endOfWord;
    }
}

Using an array here makes looksups faster since we can directly index into the correct position using ch - 'a' . If you expect other characters (like uppercase or symbols), consider using a HashMap<Character, TrieNode> instead.

Inserting Words into the Trie

Insertion involves going through each character of the word and adding nodes as needed. Start at the root node and for each character:

• If the child node doesn't exist, create it.
• Move to the child node.
• At the end of the word, mark the last node as the end of a word.

Here's how that looks in code:

 public class Trie {
    private TrieNode root;

    public Trie() {
        root = new TrieNode();
    }

    public void insert(String word) {
        TrieNode current = root;
        for (char ch : word.toCharArray()) {
            if (current.getChild(ch) == null) {
                current.setChild(ch, new TrieNode());
            }
            current = current.getChild(ch);
        }
        current.setEndOfWord(true);
    }
}

This ensures that all words are stored efficiently and overlapping prefixes are shared among different words.

Searching for Words or Prefixes

Searching works similarly to insertion but stops early if a character isn't found. There are two main cases:

1. Exact word match – requires reaching the end of the word and checking if isEndOfWord is true.
2. Prefix search – just checks whether the path exists, regardless of isEndOfWord .

 public boolean search(String word) {
    TrieNode current = root;
    for (char ch : word.toCharArray()) {
        current = current.getChild(ch);
        if (current == null) {
            return false;
        }
    }
    return current.isEndOfWord(); // Only return true if it's marked as end of a word
}

public boolean startsWith(String prefix) {
    TrieNode current = root;
    for (char ch : prefix.toCharArray()) {
        current = current.getChild(ch);
        if (current == null) {
            return false;
        }
    }
    return true;
}

These methods make it easy to support both exact searches and autocomplete-style suggestions.

Handling Edge Cases and Improvements

A few edge cases are worth considering:

• Empty strings: You might want to decide whether to allow them or not.
• Case sensitivity: Convert input to lowercase before processing unless you want case-sensitive behavior.
• Memory optimization: For large datasets, consider compressing the trie or switching to a ternary search tree.

Also, if you're planning to implement deletion later, keep track of how many words use each node so you know when it's safe to remove one.

So, implementing a basic trie in Java boils down to creating a proper node structure and carefully handling insertion and lookup logic. It's not too complicated once you get the structure right, but small mistakes — like forgetting to mark the end of a word — can cause bugs that are tricky to trace.

Basically that's it.

The above is the detailed content of How to implement a Trie data structure in Java?. For more information, please follow other related articles on the PHP Chinese website!