• Home
• com.github.javadev
• leetcode-in-java
• 1.38
• source code
• complexity.md

×

Project download

Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $

You can buy this project and download/modify it how often you want.

g0201_0300.s0208_implement_trie_prefix_tree.complexity.md Maven / Gradle / Ivy

**Time Complexity (Big O Time):**

1. **Insertion (insert):**
   - In the `insert` method, the program iterates through the characters of the input word, and for each character, it follows the corresponding child node in the Trie.
   - The number of iterations depends on the length of the word, which is O(word.length()).
   - Since each character is processed once, the insertion of a single word takes O(word.length()) time.

2. **Search (search):**
   - In the `search` method, the program iterates through the characters of the input word, following the corresponding child nodes in the Trie.
   - The number of iterations depends on the length of the word, which is O(word.length()).
   - In the worst case, when the Trie contains a large number of words with the same prefix, searching for a word could take O(word.length()) time.

3. **StartsWith (startsWith):**
   - The `startsWith` method calls the `search` method to find whether any word starts with the given prefix.
   - This is similar to the search operation and also takes O(prefix.length()) time.

Overall, the time complexity for insertion, search, and startsWith operations in the Trie is O(word.length()) or O(prefix.length()), depending on the length of the word or prefix being processed.

**Space Complexity (Big O Space):**

1. **TrieNode Array (children):**
   - The Trie is represented using a tree structure where each node (TrieNode) has an array of children (of size 26 for lowercase English letters).
   - In the worst case, where all words are distinct and there are no common prefixes, the Trie would have a node for each character in all words.
   - The space complexity for the TrieNode array is O(N), where N is the total number of characters in all inserted words.

2. **Recursive Call Stack:**
   - During insertion and search operations, the program uses recursion, which results in a function call stack.
   - The depth of the call stack is bounded by the length of the word or prefix being processed.
   - In the worst case, this depth can be O(word.length()) or O(prefix.length()).
  
3. **Other Variables:**
   - The `root` variable is a constant space requirement.
   - The `startWith` variable is also constant space.

The dominant factor in the space complexity is typically the TrieNode array, which is O(N), where N is the total number of characters in all inserted words.

In summary, the space complexity of this Trie implementation is O(N), and the time complexity for insertion, search, and startsWith operations is O(word.length()) or O(prefix.length()), depending on the length of the word or prefix being processed.
                                                                                                                                   8