Complete names.py

names/bst.py

@@ -0,0 +1,40 @@
+from dll import DoublyLinkedList
+
+
+class BinarySearchTree:
+    def __init__(self, value):
+        self.value = value
+        self.left = None
+        self.right = None
+
+    def insert(self, value):
+        if value < self.value:
+            if self.left == None:
+                self.left = BinarySearchTree(value)
+            else:
+                self.left.insert(value)
+        else:
+            if self.right == None:
+                self.right = BinarySearchTree(value)
+            else:
+                self.right.insert(value)
+
+    def contains(self, target):
+        if self.value == target:
+            return True
+        elif target < self.value:
+            if self.left is not None:
+                return self.left.contains(target)
+            else:
+                return False
+        elif target > self.value:
+            if self.right is not None:
+                return self.right.contains(target)
+            else:
+                return False
+
+    def get_max(self):
+        if self.right is not None:
+            return self.right.get_max()
+        else:
+            return self.value

names/dll.py

@@ -0,0 +1,135 @@
+"""Each ListNode holds a reference to its previous node
+as well as its next node in the List."""
+
+
+class ListNode:
+    def __init__(self, value, prev=None, next=None):
+        self.value = value
+        self.prev = prev
+        self.next = next
+
+    """Wrap the given value in a ListNode and insert it
+  after this node. Note that this node could already
+  have a next node it is point to."""
+
+    def insert_after(self, value):
+        current_next = self.next
+        self.next = ListNode(value, self, current_next)
+        if current_next:
+            current_next.prev = self.next
+
+    """Wrap the given value in a ListNode and insert it
+  before this node. Note that this node could already
+  have a previous node it is point to."""
+
+    def insert_before(self, value):
+        current_prev = self.prev
+        self.prev = ListNode(value, current_prev, self)
+        if current_prev:
+            current_prev.next = self.prev
+
+    """Rearranges this ListNode's previous and next pointers
+  accordingly, effectively deleting this ListNode."""
+
+    def delete(self):
+        if self.prev:
+            self.prev.next = self.next
+        if self.next:
+            self.next.prev = self.prev
+
+
+"""Our doubly-linked list class. It holds references to
+the list's head and tail nodes."""
+
+
+class DoublyLinkedList:
+    def __init__(self, node=None):
+        self.head = node
+        self.tail = node
+        self.length = 1 if node is not None else 0
+
+    def __len__(self):
+        return self.length
+
+    def add_to_head(self, value):
+        new_node = ListNode(value)
+        self.length += 1
+
+        if not self.head and not self.tail:  # if there's no head or tail. E.g. the list is empty
+            self.head = new_node
+            self.head.prev = new_node
+            self.tail = new_node
+        else:
+            new_node.next = self.head
+            self.head.prev = new_node
+            self.head = new_node
+
+    def remove_from_head(self):
+        value = self.head.value
+        self.delete(self.head)
+        return value
+
+    def add_to_tail(self, value):
+        new_node = ListNode(value)
+        self.length += 1
+
+        if not self.head and not self.tail:  # if there's no head or tail. E.g. the list is empty
+            self.head = new_node
+            self.tail = new_node
+        else:
+            new_node.prev = self.tail
+            self.tail.next = new_node
+            self.tail = new_node
+
+    def remove_from_tail(self):
+        value = self.tail.value
+        self.delete(self.tail)
+        return value
+
+    def move_to_front(self, node):
+        if node is self.head:
+            return
+
+        value = node.value
+
+        if node is self.tail:
+            self.remove_from_tail()
+        else:
+            node.delete()
+            self.length -= 1
+
+        self.add_to_head(value)
+
+    def move_to_end(self, node):
+        if node is self.tail:
+            return
+
+        value = node.value
+
+        if node is self.head:
+            self.remove_from_head()
+            self.add_to_tail(value)
+        else:
+            node.delete()
+            self.length -= 1
+            self.add_to_tail(value)
+
+    def delete(self, node):
+        if not self.head and not self.tail:  # if there's no head or tail. E.g. the list is empty
+            return
+
+        self.length -= 1
+        if self.head == self.tail:  # if there's only one node in the list
+            self.head = None        # head is none
+            self.tail = None  # tail is none
+        elif self.head == node:     # if head is the node
+            self.head = self.head.next
+            node.delete()
+        elif self.tail == node:
+            self.tail = self.node.prev
+            node.delete()
+        else:
+            node.delete()
+
+    def get_max(self):
+        pass

names/names.py

@@ -1,4 +1,5 @@
 import time
+from bst import BinarySearchTree
 
 start_time = time.time()
 
@@ -11,12 +12,15 @@
 f.close()
 
 duplicates = []
-for name_1 in names_1:
-    for name_2 in names_2:
-        if name_1 == name_2:
-            duplicates.append(name_1)
+bst = BinarySearchTree(names_1[0])
 
-end_time = time.time()
-print (f"{len(duplicates)} duplicates:\n\n{', '.join(duplicates)}\n\n")
-print (f"runtime: {end_time - start_time} seconds")
+for name1 in names_1[1:]:
+    bst.insert(name1)
+
+for name2 in names_2:
+    if bst.contains(name2):
+        duplicates.append(name2)
 
+end_time = time.time()
+print(f"{len(duplicates)} duplicates:\n\n{', '.join(duplicates)}\n\n")
+print(f"runtime: {end_time - start_time} seconds")