add cs6006 recitations

Author: prateek041

cs-6006/recitations/2/dynamic_array.py

@@ -0,0 +1,108 @@
+from typing import List
+import math
+
+
+class Dynamic_Array:
+    def __init__(self):
+        self.size = 0
+        self.array = []
+        self.array_value_bound = 0
+        pass
+
+    def __len__(self):
+        return self.size
+
+    def __iter__(self):
+        yield self.array
+
+    def build(self, x: List[int]):
+        for index, item in enumerate(x):
+            while index >= self.size:
+                self._resize()
+            self.array[index] = item
+        self.array_value_bound = len(x)
+        return self
+
+    def _resize(self):
+        current_size = self.size if self.size > 0 else 1
+        new_size = current_size * 2
+        new_array = [None]*new_size
+        new_array = self._old_to_new(True, new_array)
+        self.array = new_array
+        self.size = len(new_array)
+
+    def _old_to_new(self, isBuildProcess, new_array: List[int])->List[int]:
+        if self.size == 0:
+            return new_array
+        if isBuildProcess:
+            for index, _ in enumerate(self.array):
+                new_array[index] = self.array[index]
+        else:
+            for index in range(self.array_value_bound):
+                new_array[index] = self.array[index]
+        return new_array
+
+
+    def insert_last(self, item: int)-> None:
+        if self.size == self.array_value_bound:
+            self._resize()
+            return self.insert_last(item)
+        self.array[self.array_value_bound] = item
+
+    def _resize_decrese(self):
+        current_size = self.size if self.size > 0 else 1
+        new_size = math.floor(current_size / 2)
+        new_array = [None]*new_size
+        new_array = self._old_to_new(False, new_array)
+        self.array = new_array
+        self.size = len(new_array)
+
+
+    def delete_last(self):
+        self.array[self.array_value_bound - 1] = None
+        print("comparing to",math.floor((self.size)/4))
+        
+        if self.array_value_bound <= math.floor((self.size)/4):
+            print("decresing size")
+            self._resize_decrese()
+            self.size = len(self.array) - 1
+        self.array_value_bound -= 1
+        print("final array", self.array)
+
+    def insert_at(self, index):
+        pass
+
+    def delete_at(self):
+        pass
+
+    def insert_first(self):
+        pass
+
+    def delete_first(self):
+        pass
+
+test = [1, 2, 3, 4, 5]
+d_array = Dynamic_Array().build(test)
+print("STARTING WITH", d_array.array)
+# [1, 2, 3, 4, 5, None, None, None]
+print("DELETE OPERATION")
+d_array.delete_last()
+# [1, 2, 3, 4, None, None, None, None]
+
+print("DELETE OPERATION")
+d_array.delete_last()
+# [1, 2, 3, None, None, None, None, None]
+
+print("DELETE OPERATION")
+d_array.delete_last()
+# [1, 2, None, None, None, None, None, None]
+# [1, 2, None, None]
+
+print("DELETE OPERATION")
+d_array.delete_last()
+# [1, None, None, None]
+# [1, None]
+
+print("FINALLY")
+for item in d_array:
+    print(item)

cs-6006/recitations/2/linked-list.py

@@ -0,0 +1,99 @@
+# Node class is a single node in the linked list.
+class Node:
+    def __init__(self, x):
+        self.node = x 
+        self.next = None
+
+
+class Linked_List:
+    def __init__(self):
+        self.head = None
+        self.size = 0
+
+    def __len__(self):
+        return self.size
+
+    def __iter__(self):
+        node = self.head
+
+        while(node):
+            yield node.node
+            node = node.next
+
+    def build(self, items):
+        if(len(items) <= 0):
+            self.head = None
+            self.size = 0
+            return self
+
+        self.head = Node(items[0])
+        temp_pointer = self.head
+        self.size += 1
+        for item in items[1:]:
+            new_node = Node(item)
+            temp_pointer.next = new_node
+            temp_pointer = new_node
+            self.size += 1
+        return self
+
+
+    def get_at(self, index):
+        if(self.head) == None: return None
+        start = self.head
+        while index > 1:
+            if (start == None):
+                return None
+            start = start.next
+            index -= 1 
+
+    def set_at(self, item, index):
+        node = self.get_at(index-1)
+        if (node == None): 
+            return "index out of range"
+        new_node = Node(item)
+        if (node.next == None):
+            node.next = new_node
+        next_node = node.next
+        new_node.next = next_node.next
+        node.next = new_node
+
+    def insert_first(self, x):
+        new_node = Node(x)
+        new_node.next = self.head
+        self.head = new_node
+        
+
+    def delete_first(self):
+        if(self.head == None): return None
+        self.head = self.head.next
+
+
+    def insert_at(self, index, item):
+        node = self.get_at(index-1)
+        if node == None:
+            return "index out of range"
+        temp_node = node
+        new_node = Node(item)
+        new_node.next = temp_node.next
+        node.next = new_node
+        self.size += 1
+
+    def delete_at(self, index):
+        prev_node = self.get_at(index-1)
+        if prev_node== None: return "index out of range"
+        if (prev_node.next == None): return self
+        node_to_delete = prev_node.next
+        prev_node.next = node_to_delete.next
+
+
+    def insert_last(self, item):
+        new_node = Node(item)
+        if not self.head:  # If the list is empty
+            self.head = new_node
+        else:
+            last_node = self.get_at(self.size)
+            last_node.next = new_node
+
+    def delete_last(self):
+        return self.delete_at(self.size)
+        

cs-6006/recitations/tree/BST.py

@@ -0,0 +1,74 @@
+from binary_tree import BinaryNode, BinaryTree
+
+class BST_Node(BinaryNode):
+    def subtree_find(self, A):
+        """
+        If A is self.item return it.
+        If A is greater than self.item then go to the right
+        subtree, else go to the left subtree.
+        """
+        if A < self.item.key:
+            if self.left:
+                return self.left.subtree_find(A)
+        elif A > self.item.key:
+            if self.right:
+                return self.right.subtree_find(A)
+        else: return A
+        return None
+
+    def subtree_find_next(self, A):
+        """
+        If A is found, return first item in the right subtree.
+        If A is not found, return item itself.
+        """
+        if self.item.key <= A:
+            if self.right:
+                return self.right.subtree_find_next(A)
+            else: return None
+        elif self.left:
+            B = self.left.subtree_find_next(A)
+            if B: return B
+        return self
+
+    def subtree_find_prev(self, A):
+        if self.item.key >= A:
+            if self.left: return self.left.subtree_find_prev(A)
+            # end of the tree.
+            else: return None
+        elif self.right:
+            return self.right.subtree_find_prev(A)
+        return self
+
+    def subtree_insert(self, A):
+        pass
+
+
+class Set_Binary_Tree(BinaryTree):
+    """
+    Top level Data structure for holding a Set Binary Tree
+    """
+    def __init__(self): super().__init__(BST_Node)
+
+    def build_tree(self, X):
+        pass
+
+    def find_min(self):
+        pass
+
+    def find_max(self):
+        pass
+
+    def find(self, k):
+        pass
+
+    def find_next(self, k):
+        pass
+
+    def find_prev(self, k):
+        pass
+
+    def insert(self, x):
+        pass
+
+    def delete(self, k):
+        pass