first commit

Author: daudn

data_structures/binary_tree.py

@@ -0,0 +1,61 @@
+class Node:
+    def __init__(self, value):
+        self.value = value
+        self.left = None
+        self.right = None
+
+
+class BinarySearchTree:
+    def __init__(self):
+        self.root = None
+
+    def insert(self, value):
+        new_node = Node(value)
+        if self.root is None:
+            self.root = new_node
+            return True
+        temp = self.root
+        while (True):
+            if new_node.value == temp.value:
+                return False
+            if new_node.value < temp.value:
+                if temp.left is None:
+                    temp.left = new_node
+                    return True
+                temp = temp.left
+            else:
+                if temp.right is None:
+                    temp.right = new_node
+                    return True
+                temp = temp.right
+
+    def contains(self, value):
+        # if self.root is None:
+        #     return False
+        temp = self.root
+        while (temp is not None):
+            if value < temp.value:
+                temp = temp.left
+            elif value > temp.value:
+                temp = temp.right
+            else:
+                return True
+        return False
+
+
+my_tree = BinarySearchTree()
+my_tree.insert(2)
+my_tree.insert(1)
+my_tree.insert(3)
+my_tree.insert(200)
+my_tree.insert(4)
+my_tree.insert(8)
+my_tree.insert(100)
+
+print(my_tree.root.value)
+print(my_tree.root.left.value)
+print(my_tree.root.right.value)
+# print(my_tree.root.right.left.value)
+print(my_tree.root.right.right.value)
+
+print(my_tree.contains(200))

data_structures/doubly_linked_list.py

@@ -0,0 +1,151 @@
+class Node:
+    def __init__(self, value):
+        self.value = value
+        self.next = None
+        self.prev = None
+
+
+class DoublyLinkedList:
+    def __init__(self, value):
+        new_node = Node(value)
+        self.head = new_node
+        self.tail = new_node
+        self.length = 1
+
+    def print_list(self):
+        full_list = []
+        temp = self.head
+        while temp is not None:
+            print(temp.value)
+            # full_list.append(temp.value)
+            temp = temp.next
+        # print(full_list)
+
+    def append(self, value):
+        new_node = Node(value)
+        if self.head is None:
+            self.head = new_node
+            self.tail = new_node
+        else:
+            self.tail.next = new_node
+            new_node.prev = self.tail
+            self.tail = new_node
+        self.length += 1
+        return True
+
+    def pop(self):
+        if self.length == 0:
+            return None
+        temp = self.tail
+        if self.length == 1:
+            self.head = None
+            self.tail = None
+        else:
+            self.tail = self.tail.prev
+            self.tail.next = None
+            temp.prev = None
+        self.length -= 1
+        return temp
+
+    def prepend(self, value):
+        new_node = Node(value)
+        if self.length == 0:
+            self.head = new_node
+            self.tail = new_node
+            return new_node
+        else:
+            new_node.next = self.head
+            self.head.prev = new_node
+            self.head = new_node
+        self.length += 1
+        return True
+
+    def pop_first(self):
+        if self.length == 0:
+            return None
+        temp = self.head
+        if self.length == 1:
+            self.head = None
+            self.tail = None
+        else:
+            self.head = self.head.next
+            self.head.prev = None
+            temp.next = None
+        self.length -= 1
+        return temp
+
+    def get(self, index):
+        if index < 0 or index >= self.length:
+            return None
+        temp = self.head
+        if index < self.length / 2:
+            for _ in range(index):
+                temp = temp.next
+        else:
+            temp = self.tail
+            for _ in range(self.length - 1, index, -1):
+                temp = temp.prev
+        return temp
+
+    def set_value(self, index, value):
+        temp = self.get(index)
+        if temp:
+            temp.value = value
+            return True
+        return False
+
+    def insert(self, index, value):
+        if index < 0 or index > self.length:
+            return False
+        if index == 0:
+            return self.prepend(value)
+        if index == self.length:
+            return self.append(value)
+
+        new_node = Node(value)
+        before = self.get(index - 1)
+        after = before.next
+
+        new_node.prev = before
+        new_node.next = after
+        before.next = new_node
+        after.prev = new_node
+        self.length += 1
+        return True
+
+    def remove(self, index):
+        if index < 0 or index >= self.length:
+            return None
+        if index == 0:
+            return self.pop_first()
+        if index == self.length - 1:
+            return self.pop()
+
+        temp = self.get(index)
+        temp.next.prev = temp.prev
+        temp.prev.next = temp.next
+        # Same code
+        # before = temp.prev
+        # after = temp.next
+        # before.next = after
+        # after.prev = before
+        # Same code
+        temp.next = None
+        temp.prev = None
+        self.length -= 1
+        return temp
+
+
+my_doubly_linked_list = DoublyLinkedList(2)
+my_doubly_linked_list.append(3)
+my_doubly_linked_list.append(4)
+my_doubly_linked_list.print_list()
+
+my_doubly_linked_list.pop()
+
+my_doubly_linked_list.prepend(1)
+print(my_doubly_linked_list.get(1))
+my_doubly_linked_list.insert(1, 100)
+my_doubly_linked_list.remove(1)
+print("Final list:")
+my_doubly_linked_list.print_list()

data_structures/graph.py

@@ -0,0 +1,61 @@
+class Graph:
+    def __init__(self):
+        self.adj_list = {}
+
+    def print_graph(self):
+        for vertex in self.adj_list:
+            print(vertex, ": ", self.adj_list[vertex])
+
+    def add_vertex(self, vertex):
+        if vertex not in self.adj_list.keys():
+            self.adj_list[vertex] = []
+            return True
+        return False
+
+    def add_edge(self, v1, v2):
+        if v1 in self.adj_list.keys() and v2 in self.adj_list.keys():
+            self.adj_list[v1].append(v2)
+            self.adj_list[v2].append(v1)
+            return True
+        return False
+
+    def remove_edge(self, v1, v2):
+        if v1 in self.adj_list.keys() and v2 in self.adj_list.keys():
+            try:
+                self.adj_list[v1].remove(v2)
+                self.adj_list[v2].remove(v1)
+            except ValueError:
+                pass
+            return True
+
+        return False
+
+    def remove_vertex(self, vertex):
+        if vertex in self.adj_list.keys():
+            for other_vertex in self.adj_list[vertex]:
+                self.adj_list[other_vertex].remove(vertex)
+            del self.adj_list[vertex]
+            return True
+        return False
+
+
+my_graph = Graph()
+
+my_graph.add_vertex("A")
+my_graph.add_vertex("B")
+my_graph.add_vertex("C")
+my_graph.add_vertex("D")
+
+my_graph.add_edge("A", "B")
+my_graph.add_edge("A", "C")
+my_graph.add_edge("A", "D")
+my_graph.add_edge("B", "D")
+my_graph.add_edge("C", "D")
+
+my_graph.print_graph()
+
+my_graph.remove_vertex("D")
+my_graph.print_graph()
+# my_graph.remove_edge("A", "C")
+# my_graph.remove_edge("A", "D")
+# my_graph.print_graph()

data_structures/hash_map.py

@@ -0,0 +1,50 @@
+class HashTable:
+    def __init__(self, size=7):
+        self.data_map = [None] * size
+
+    def print_table(self):
+        for i, val in enumerate(self.data_map):
+            print(i, ": ", val)
+
+    def __hash(self, key):
+        my_hash = 0
+        for letter in key:
+            # ord = ordinal, gets the ASCII for each letter
+            # multiply it by 23 (23 is a primer number, can be any number)
+            # % modular = gives us remainer
+            my_hash = (my_hash + ord(letter) * 23) % len(self.data_map)
+        return my_hash
+
+    def set_item(self, key, value):
+        index = self.__hash(key)
+        if self.data_map[index] == None:
+            self.data_map[index] = []
+        self.data_map[index].append([key, value])
+
+    def get_item(self, key):
+        index = self.__hash(key)
+        if self.data_map[index] is not None:
+            for i in range(len(self.data_map[index])):
+                if self.data_map[index][i][0] == key:
+                    return self.data_map[index][i][1]
+        return None
+
+    def keys(self):
+        all_keys = []
+        for i in range(len(self.data_map)):
+            if self.data_map[i] is not None:
+                for j in range(len(self.data_map[i])):
+                    all_keys.append(self.data_map[i][j][0])
+        return all_keys
+
+
+my_hash_table = HashTable()
+
+my_hash_table.set_item('bolts', 1400)
+my_hash_table.set_item('washers', 50)
+my_hash_table.set_item('lumber', 70)
+
+print(my_hash_table.get_item("bolts"))
+
+print(my_hash_table.keys())
+my_hash_table.print_table()