def insert(self, str, docID):
char = str[0]
rest = str[1:]
if str == "":
raise Exception("Empty string not allowed as key")
if char in self._keyList:
ind = self._keyList.index(char)
self._nodeList[ind].insert(rest, docID)
return
else:
node = TrieNode(char)
self._nodeList.append(node)
self._keyList.append(char)
node.insert(rest, docID)
return
def insert(self, key):
cur = self.root
for c in key:
found = False
for node in cur.children:
if node.data == c:
cur = node
found = True
if not found:
new_node = TrieNode(c)
cur.children.append(new_node)
cur = new_node
cur.is_end = True
def add_text_nodes(self, node_children, text, data):
if len(text) > 0:
target_node = None
if text[0] in node_children:
target_node = node_children[text[0]]
else:
new_node = TrieNode()
if text[0] in self.node_map:
self.node_map[text[0]].append(new_node)
else:
self.node_map[text[0]] = []
self.node_map[text[0]].append(new_node)
node_children[text[0]] = new_node
target_node = new_node
if len(text) > 1:
self.add_text_nodes(target_node.children, text[1:], data)
else:
target_node.add_data(data)
def insert(self, key):
# None keys are not allowed
if key is None:
return
key = key.lower() # Keys are stored in lowercase
current_node = self.root
# Iterate the trie with the given character index,
# If the index points to None
# simply create a TrieNode and go down a level
for level in range(len(key)):
index = self.get_index(key[level])
if current_node.children[index] is None:
current_node.children[index] = TrieNode(key[level])
print(key[level] + " inserted")
current_node = current_node.children[index]
# Mark the end character as leaf node
current_node.mark_as_leaf()
print("'" + key + "' inserted")
def __init__(self) -> None:
self.root = TrieNode('\0')
from trie_node import TrieNode
forbidden_words = [
'darn', 'rats', 'egg', 'fuzzy', 'kthx', 'haha', 'ugh', '777', 'cheese',
'i', 'l', 'o', '0', '1'
]
forbidden_words_trie = TrieNode('', False, True)
for word in forbidden_words:
forbidden_words_trie.insert(word.upper())
def __init__(self):
self.root = TrieNode(None, None)
self.size = 0
class Trie:
__slots__ = 'root', 'size'
def __init__(self):
self.root = TrieNode(None, None)
self.size = 0
def insert(self, entry):
node = self.root
for letter in entry.headword.lower():
child = node.children[letter]
if child:
node = child
else:
node = node.insert_child(letter)
node.entries.append(entry)
self.size += 1
def get_node(self, word):
node = self.root
for letter in word.lower():
node = node.children[letter]
if node == None:
return None
return node
def search(self, word, case_sensitive):
node = self.get_node(word)
if node == None or len(node.entries) == 0:
return []
if case_sensitive:
entries = []
for entry in node.entries:
if entry.headword == word:
entries.append(entry)
return entries
else:
return node.entries.copy()
def remove(self, word, case_sensitive):
node = self.get_node(word)
if node == None or len(node.entries) == 0:
return
if case_sensitive:
i = 0
while i < len(node.entries):
if node.entries[i].headword == word:
del node.entries[i]
self.size -= 1
else:
i += 1
else:
self.size -= len(node.entries)
del node.entries[:]
while len(node.child_keys) == 0 and len(node.entries) == 0:
letter = node.letter
node = node.parent
if node == None:
break
node.remove_child(letter)
def get_neighbors(self, word, radius):
node = self.get_node(word)
if node == None:
raise WordNotFound(word)
predecessors = []
count = 0
neighbor = node.previous_node()
while neighbor and count < radius:
if len(neighbor.entries) > 0:
predecessors.append(neighbor.get_lower_word())
count += 1
neighbor = neighbor.previous_node()
successors = []
count = 0
neighbor = node.next_node()
while neighbor and count < radius:
if len(neighbor.entries) > 0:
successors.append(neighbor.get_lower_word())
count += 1
neighbor = neighbor.next_node()
return predecessors, successors
def match_prefix(self, prefix, case_sensitive):
node = self.get_node(prefix)
if node == None:
return
if case_sensitive:
yielded = set()
for entry in node.values():
word = entry.headword
if word.startswith(prefix) and word not in yielded:
yield word
yielded.add(word)
else:
yield from node.keys()
def load(self, file_name):
stream = open(file_name, 'r')
for line in stream:
line = line.strip()
if line == '':
continue
try:
entry = DictEntry.from_line(line)
except InvalidSyntax as exception:
print(exception)
else:
self.insert(entry)
stream.close()
def write(self, file_name):
stream = open(file_name, 'w')
for entry in self.root.values():
entry.write(stream)
stream.close()
def __init__(self):
self.root = TrieNode(None)
self.count = 0
def bfs_traversal(self):
if self.root == None:
return False
print(self.root.value)
queue = deque()
for index in self.root.children:
queue.append(self.root.children[index])
while len(queue) > 0:
val = queue.pop()
print(val.value)
for child in val.children:
queue.append(val.children[child])
return True
if __name__ == "__main__":
var = Trie()
# var.root = TrieNode(1)
# print(var.root.value)
val = TrieNode(1)
val.add_child(2)
val.children[2].add_child(6)
val.children[2].children[6].add_child(7)
val.add_child(3)
var.root = val
var.dfs_traversal_print()
print("_____")
var.bfs_traversal()
def __init__(self):
self.root = TrieNode() # Root node