Feedback

.vscode/settings.json

@@ -0,0 +1,3 @@
+{
+    "python.pythonPath": "/usr/local/bin/python3"
+}

adt_binary_tree.py

@@ -5,17 +5,73 @@ def __init__(self, value):
         self.value = value
         self.left = None
         self.right = None
+
+    def insert(self, data):
+        # if self.value:
+        if data < self.value:
+            if self.left is None:
+                self.left = Node(data)
+            else:
+                self.left.insert(data)
+        elif data > self.value:
+            if self.right is None:
+                self.right = Node(data)
+            else:
+                self.right.insert(data)
+        # else:
+        #     self.value = data
+
+    def find(self, val):
+        if val < self.value:
+            if self.left == None:
+                return None
+            else:
+                return self.left.find(val)
+        elif val > self.value:
+            if self.right == None:
+                return None
+            else:
+                return self.right.find(val)
+        elif val == self.value:
+            return self
+        else:
+            return None
 
 class Tree:
+
     def __init__(self):
         self.root = None
 
     def get_root(self):
         return self.root
 
-    def add_node(self, value):
-        pass
+    def add_node(self, node):
+        if self.root:
+            self.root.insert(node)
+        else:
+            self.root = Node(node)
+        # node = Node(node)
+        # if self.root:
+        #     if node.value < self.root.value:
+        #         if self.root.left == None:
+        #             self.root = node
+        #         else:
+        #             self.add_node(node)
+        #     elif node.value > self.root.value:
+        #         if self.root.right == None:
+        #             self.root = node
+        #         else:
+        #             self.add_node(node)
+        # else:
+        #     self.root = node
 
     def find_node(self, value):
-        pass
-
+        return self.root.find(value)
+        # if self.root:
+        #     if value < self.root.value:
+        #         if self.root.left == None:
+        #             return False
+        #         else:
+        #             self.find_node(value)
+        #     elif value == self.root.value:
+        #         return 

adt_linked_list.py

@@ -10,8 +10,24 @@ def __init__(self, data):
 class LinkedList:
     # This method will run when you create a new
     # linked list object instance
-    def __init__(self):
-        self.head = None
+    def __init__(self, elements=None):
+        if elements:
+            self.head = Node(elements[0])
+            # next item to link with
+            next_item = self.head
+            for i in range(1, len(elements)):
+                next_item.next = Node(elements[i])
+                next_item = next_item.next
+        else:
+            self.head = None
+        # for item, index in enumerate(list):
+        #     item = Node(item)
+        # for item, index in enumerate(list.reverse):
+        #     if index == len(list.reverse):
+        #         self.head = list[0]
+        #     else:
+        #         if index != 0:
+        #             item.next = list.reverse[index-1]
 
     # This method will make a nicely printed version
     # of your linked list structure, don't change it!
@@ -28,16 +44,32 @@ def __repr__(self):
     def add_to_start(self, node):
         node.next = self.head
         self.head = node
-
+    
     # Method to add a new node at the end of the linked list
     def add_to_end(self, node):
-        pass
+        if self.head:
+            next_item = self.head
+            while(next_item.next):
+                next_item = next_item.next
+            next_item.next=node
+        else:
+            self.head = node
+
 
     # Method to add a new node after an existing element
     def add_after(self, target_node_data, new_node):
-        pass
+        next_item = self.head
+        while (next_item.next.data != target_node_data) and (next_item.next.next.data != target_node_data):
+            next_item = next_item.next
+        new_node.next = next_item.next.next
+        next_item.next.next = new_node
 
     # Method to remove a node from the linked list
     def remove_node(self, target_node_data):
-        pass
+        next_item = self.head
+        while (next_item.next.data != target_node_data) and (next_item.next.next.data != target_node_data):
+            next_item = next_item.next
+        next_item.next = next_item.next.next
+
+
 

adt_queue.py

@@ -1,14 +1,23 @@
 class Queue():
     def __init__(self, size):
         self.size = size
-        self.front_index = -1
+        self.front_index = 0
         self.end_index = -1
         self.storage = [""] * size
 
     # add new data to the end of the queue
     def enqueue(self, new_element):
-        pass
+
+        self.end_index += 1
+        if self.end_index < self.size:
+            self.storage[self.end_index] = new_element
+        else:
+            self.end_index -= self.size
+            self.storage[self.end_index-self.size] = new_element
 
     # remove data from the front of the queue
     def dequeue(self):
-        pass
+        dequeued = self.storage[self.front_index]
+        self.storage[self.front_index] = None
+        self.front_index += 1
+        return dequeued

adt_stack.py

@@ -8,13 +8,19 @@ def __init__(self, size):
 
     # add new data to the stack - my_stack.push("FOO")
     def push(self, new_element):
-        pass
+        # if self.top_of_stack <=  self.size-1:
+        self.storage[self.top_of_stack+1] = new_element
+        self.top_of_stack += 1
 
     # remove and return the top of the stack - my_stack.pop()
     def pop(self):
-        pass
+        # if self.top_of_stack != -1:
+        popped = self.storage[self.top_of_stack]
+        # self.storage[self.top_of_stack+1] = ''
+        self.top_of_stack -= 1
+        return popped
 
     # looking at the top of the stack, but don't change anything! - my_stack.peek()
     def peek(self):
-        pass
+        return self.storage[self.top_of_stack]
 

test_adt_binary_tree.py

@@ -44,4 +44,6 @@ def test_find_missing_node():
     tree.add_node(2)
     tree.add_node(11)
 
-    assert tree.find_node(10) is None
+    assert tree.find_node(10) is None
+
+test_find_existing_node()

test_adt_linked_list.py

@@ -41,4 +41,4 @@ def test_remove_node():
     llist.add_to_end(Node("d"))
     llist.add_after("b", Node("c"))
     llist.remove_node("b")
-    assert str(llist) == "a -> c -> d -> None"
+    assert str(llist) == "a -> c -> d -> None"