Merge pull request #1 from nedssoft/chinedu-orie

Data structure sprint challenge

Author: nobioma1

names/binary_search_tree.py

@@ -0,0 +1,70 @@
+import sys
+
+class BinarySearchTree:
+    def __init__(self, value):
+        self.value = value
+        self.left = None
+        self.right = None
+
+    # Insert the given value into the tree
+    def insert(self, value):
+          # LEFT CASE
+        # check if our new nodes value is less than the current nodes value
+        if value < self.value:
+            # does it have a child to the left?
+            if self.left is not None:
+                self.left.insert(value)
+                # place our new node here
+            # otherwise
+            else:
+                self.left = BinarySearchTree(value)
+                # repeat process for the left
+
+        # RIGHT CASE
+        
+        # check if the new nodes value is greater than or equal to the current nodes value
+        if value >= self.value:
+            # does it have a child to the right?
+            if self.right is not None:
+                self.right.insert(value)
+                # place our new node here
+            # otherwise
+            else:
+                self.right = BinarySearchTree(value)
+                # repeat the process for the right
+
+    # Return True if the tree contains the value
+    # False if it does not
+    def contains(self, target):
+
+        current_value = self.value
+        if current_value == target:
+            return True
+        
+        # Check if the target is less than the current node value
+        if target < current_value:
+
+            # Check if left is not None
+            if self.left is not None:
+
+                # Repeat the process towards the left
+                return self.left.contains(target)
+            else:
+
+                # It means the target is not at the left
+                return False
+
+        # Let's search the rightnode
+        if target >= current_value:
+
+            # Check if the right is none
+            if self.right is None:
+
+                # Then it is not at the right
+                return False
+            else:
+                return self.right.contains(target)
+
+
+
+    

names/names.py

@@ -1,4 +1,5 @@
 import time
+from binary_search_tree import BinarySearchTree
 
 start_time = time.time()
 
@@ -13,10 +14,30 @@
 duplicates = []  # Return the list of duplicates in this data structure
 
 # Replace the nested for loops below with your improvements
-for name_1 in names_1:
-    for name_2 in names_2:
-        if name_1 == name_2:
-            duplicates.append(name_1)
+# for name_1 in names_1:
+#     for name_2 in names_2:
+#         if name_1 == name_2:
+#             duplicates.append(name_1)
+
+"""
+    First pass, runtime: 1.120605230331421 seconds
+"""
+# for i in range(len(names_1)-1):
+#     if names_1[i] in names_2:
+#         duplicates.append(names_1[i])
+
+"""
+Using BST, runtime: 0.10721707344055176 seconds
+"""
+# Create a BST with names_2
+bst = BinarySearchTree(names_2[0])
+for i in range(1, len(names_2)):
+    bst.insert(names_2[i])
+# Loop through names_1 and call bst.contans()
+
+for name in names_1:
+    if bst.contains(name):
+        duplicates.append(name)
 
 end_time = time.time()
 print (f"{len(duplicates)} duplicates:\n\n{', '.join(duplicates)}\n\n")

reverse/reverse.py

@@ -44,4 +44,27 @@ def contains(self, value):
 
   def reverse_list(self):
     # TO BE COMPLETED
-    pass
+
+    # if the head is None
+    if self.head is None:
+
+      # Return none
+      return None
+
+    # Create an empty node
+    prev = None
+
+    # Assign the head to a current var
+    current = self.head
+
+    # Perform swap
+    while current:
+      # Assign the current node next to a var
+      next_node = current.next_node
+      # Assign the prev to the next node
+      current.next_node = prev
+      prev = current
+      current = next_node
+     
+    self.head = prev 
+

ring_buffer/ring_buffer.py

@@ -1,20 +1,35 @@
 from doubly_linked_list import DoublyLinkedList
 
-
 class RingBuffer:
     def __init__(self, capacity):
         self.capacity = capacity
         self.current = None
         self.storage = DoublyLinkedList()
 
     def append(self, item):
-        pass
+
+        if (len(self.storage) == self.capacity):
+            self.current.value = item
+            if (self.current.next):
+                self.current = self.current.next
+            else:
+                self.current = self.storage.head
+        else:
+            self.storage.add_to_tail(item)
+            self.current = self.storage.head
 
     def get(self):
         # Note:  This is the only [] allowed
         list_buffer_contents = []
-
+        if len(self.storage) == 0:
+            return list_buffer_contents
         # TODO: Your code here
+        else:
+          current_node = self.storage.head
+          while current_node:
+              if (current_node.value):
+                  list_buffer_contents.append(current_node.value)  
+              current_node = current_node.next
 
         return list_buffer_contents
 
@@ -23,10 +38,16 @@ def get(self):
 
 class ArrayRingBuffer:
     def __init__(self, capacity):
-        pass
+        self.storage = [None]*capacity
+        self.capacity = capacity
+        self.current =0
 
     def append(self, item):
-        pass
+        if (self.current == self.capacity):
+            self.current = 0
+        self.storage[self.current] = item
+        self.current += 1
 
     def get(self):
-        pass
+        
+        return [i for i in self.storage if i is not None]