From f2776ddd908625471efbf39cddb647794e80bae3 Mon Sep 17 00:00:00 2001
From: Shinjanee Gupta <shinjaneegupta@gmail.com>
Date: Thu, 5 Feb 2026 11:29:46 -0800
Subject: [PATCH] Design2

---
 hashmap.py | 73 ++++++++++++++++++++++++++++++++++++++++++++++++++++++
 queue.py   | 39 +++++++++++++++++++++++++++++
 2 files changed, 112 insertions(+)
 create mode 100644 hashmap.py
 create mode 100644 queue.py

diff --git a/hashmap.py b/hashmap.py
new file mode 100644
index 00000000..b943aa48
--- /dev/null
+++ b/hashmap.py
@@ -0,0 +1,73 @@
+# Time Complexity : O(1)
+# Space Complexity : O(n)
+# Did this code successfully run on Leetcode : Yes
+# Any problem you faced while coding this : No
+# Approach : use an array of buckets with linked lists to handle collisions.
+# Each bucket stores a dummy head node, and operations traverse the linked list to insert, find, or remove a key.
+
+class Node:
+    def __init__(self, key, value):
+        self.key = key
+        self.value = value
+        self.next = None
+
+class MyHashMap:
+
+    def __init__(self):
+        self.capacity = 10000
+        self.storage = [Node(None, None) for _ in range(self.capacity)]
+
+    def getHash(self, key: int) -> int:
+        return key % self.capacity
+
+    def getPrevNode(self, head: Node, key: int) -> Node:
+        prev = None
+        curr = head
+
+        while curr and curr.key != key:
+            prev = curr
+            curr = curr.next
+
+        return prev
+
+    def put(self, key: int, value: int) -> None:
+        primaryIndex = self.getHash(key)
+
+        if not self.storage[primaryIndex].key:
+            self.storage[primaryIndex] = Node(-1, -1)
+            self.storage[primaryIndex].next = Node(key, value)
+            return
+
+        prev = self.getPrevNode(self.storage[primaryIndex], key)
+
+        if not prev.next:
+            prev.next = Node(key, value)
+        else:
+            prev.next.value = value
+        
+
+    def get(self, key: int) -> int:
+        primaryIndex = self.getHash(key)
+
+        if not self.storage[primaryIndex].key:
+            return -1
+
+        prevNode = self.getPrevNode(self.storage[primaryIndex], key)
+
+        if not prevNode.next:
+            return -1
+
+        return prevNode.next.value
+
+    def remove(self, key: int) -> None:
+        primaryIndex = self.getHash(key)
+
+        if not self.storage[primaryIndex].key:
+            return
+
+        prev = self.getPrevNode(self.storage[primaryIndex], key)
+
+        if not prev.next:
+            return
+
+        prev.next = prev.next.next
\ No newline at end of file
diff --git a/queue.py b/queue.py
new file mode 100644
index 00000000..57b031f5
--- /dev/null
+++ b/queue.py
@@ -0,0 +1,39 @@
+# Time Complexity : O(1)
+# Space Complexity : O(n)
+# Did this code successfully run on Leetcode : Yes
+# Any problem you faced while coding this : No
+# Approach : We use two stacks: one (stack1) for incoming elements and another (stack2)
+# to reverse order and simulate FIFO. Elements are only transferred from stack1 to stack2 when needed.
+
+class MyQueue:
+
+    def __init__(self):
+        self.stack1 = []
+        self.stack2 = []
+        
+    def push(self, x: int) -> None:
+        self.stack1.append(x)
+        
+
+    def pop(self) -> int:
+        if self.stack2:
+            return self.stack2.pop()
+
+        while self.stack1:
+            self.stack2.append(self.stack1.pop())
+        
+        return self.stack2.pop()
+
+    def peek(self) -> int:
+        if self.stack2:
+            return self.stack2[-1]
+
+        while self.stack1:
+            self.stack2.append(self.stack1.pop())
+        
+        return self.stack2[-1]
+        
+
+    def empty(self) -> bool:
+        return self.stack1 == [] and self.stack2 == []
+