class LinkedList():
"""
This class contains an implementation of the LinkedList object which is designed to work with the AbstractNode
object. AbstractNode can be overloaded or used as it currently stands
"""
type = "list"
head = None
tail = None
size = 0
def __init__(self):
self.head = None
self.tail = None
self.size = 0
pass
def add_node(self, data, index=0):
"""
This method adds a new node either at the end or at the specified index counting from the front of the list
:param data:
:param index:
"""
#List is empty
if self.size == 0:
self.head = AbstractNode(data)
self.tail = self.head
self.head.set_prev(self.tail)
self.size += 1
#Default parameters (end of list)
elif index == 0:
new_node = AbstractNode(data)
self.tail.set_next(new_node)
old_tail = self.tail
self.tail = self.tail.get_next()
self.tail.set_prev(old_tail)
self.size += 1
#Non-default parameters (anywhere in list)
elif 0 < index < self.size:
node = self.head
for i in range(index):
node = node.get_next()
#Add the new node into the list
prev_node = node.get_prev()
new_node = AbstractNode(data)
prev_node.set_next(new_node)
new_node.set_prev(prev_node)
#Link the new node to the old node
prev_node = prev_node.get_next()
prev_node.set_next(node)
node.set_prev(prev_node)
self.size += 1
#Error if no case satisfied
else:
print("Invalid argument: add ", index)
def remove_node(self, index=-1):
"""
This method either removed a node from the end of the list or at the specified index counting from
the front of the list
:param index:
"""
return_data = None
#The list is empty
if self.size == 0:
return return_data
#Delete the last element
elif index == -1:
return_data = self.tail.get_data()
self.tail = self.tail.get_prev()
self.tail.set_next(None)
self.size -= 1
return return_data
#Delete the first element
elif index == 0:
return_data = self.head.get_data()
self.head = self.head.get_next()
self.size -= 1
return return_data
#Delete a valid element
elif 0 <= index < (self.size - 1):
node = self.head
for i in range(index):
node = node.get_next()
return_data = node.get_data()
#Get the prev node
prev_node = node.get_prev()
prev_node.set_next(node.get_next())
next_node = node.get_next()
next_node.set_prev(prev_node)
self.size -= 1
return return_data
#Error if no case satisfied
else:
print("Invalid argument: remove ", index)
return None
def print_list(self):
list_output = "Size = " + str(self.size) + " {"
node = self.head
while node is not None:
list_output += str(node.get_data()) + ", "
node = node.get_next()
print list_output + "}"
def load_data(self, data):
for datum in data:
self.add_node(datum)
def extract_data(self):
data = []
node = self.head
for i in range(self.size):
data.append(node.get_data())
node = node.get_next()
return data
class Tree():
"""
This class contains the implementation for a binary search tree (BST)
"""
type = "list"
head = None
size = 0
def __init__(self):
self.head = None
self.size = 0
pass
def add(self, data):
#Tree is empty
if self.size == 0:
self.head = AbstractNode(data)
self.size += 1
else:
curr_node = self.head
#assert isinstance(curr_node, AbstractNode)
while True:
#Right branch of current
if data > curr_node.get_data():
if curr_node.get_right() is None:
#Insert new node with data as the right child
curr_node.set_right(AbstractNode(data))
self.size += 1
break
else:
curr_node = curr_node.get_right()
#Left branch of current
elif data < curr_node.get_data():
if curr_node.get_left() is None:
#Insert new node with data as the left child
curr_node.set_left(AbstractNode(data))
self.size += 1
break
else:
curr_node = curr_node.get_left()
else:
curr_node.increment()
self.size += 1
break
def remove(self, data):
#TODO: Finish this method
#Tree is empty
if self.size == 0:
return
elif data == self.head.get_data():
self.head = None
else:
pass
def __remove__(self, curr_node, data):
pass
def print_tree(self):
self.__print_tree__(self.head, "")
def __print_tree__(self, node, prefix):
if node is not None:
count = node.get_count()
if count == 1:
print prefix, "+-", node.get_data()
else:
print prefix, "+-", node.get_data(), "x", count
self.__print_tree__(node.get_left(), prefix + " | ")
self.__print_tree__(node.get_right(), prefix + " | ")
