added more implementations

Author: dev-sire

Algorithms/BFS&DFSInBinaryTree.py

@@ -0,0 +1,45 @@
+from collections import deque
+
+class Node:
+    def __init__(self, value):
+        self.value = value
+        self.left = None
+        self.right = None
+
+def BFS(root):
+    if root is None:
+        return
+    
+    queue = deque([root])
+
+    while queue:
+        node = queue.popleft()  # dequeue a node from the front of the queue
+        print(node.value, end=' ')  # visit the node (print its value in this case)
+
+        # enqueue left child
+        if node.left:
+            queue.append(node.left)
+        # enqueue right child
+        if node.right:
+            queue.append(node.right)
+
+def DFS(node):
+    if node is None:
+        return
+    # Visit the node (print its value in this case)
+    print(node.value, end=' ')
+    # Recursively call DFS on the left child
+    DFS(node.left)
+    # Recursively call DFS on the right child
+    DFS(node.right)
+
+root = Node(1)
+root.left = Node(2)
+root.right = Node(3)
+root.left.left = Node(4)
+root.left.right = Node(5)
+
+print("Depth first search: ")
+DFS(root)
+print("\nBreadth first search: ")
+BFS(root)

Data Structures/GraphClass.py

@@ -0,0 +1,43 @@
+class Vertex:
+    def __init__(self, vertex_id):
+        self.id = vertex_id
+        self.neighbors = []
+
+    def add_neighbor(self, neighbor):
+        if neighbor not in self.neighbors:
+            self.neighbors.append(neighbor)
+
+class Graph:
+    def __init__(self):
+        self.vertices = {}
+
+    def add_vertex(self, vertex):
+        if isinstance(vertex, Vertex) and vertex.id not in self.vertices:
+            self.vertices[vertex.id] = vertex
+            return True
+        else:
+            return False
+
+    def add_edge(self, v1, v2):
+        if v1 in self.vertices and v2 in self.vertices:
+            self.vertices[v1].add_neighbor(v2)
+            self.vertices[v2].add_neighbor(v1)
+            return True
+        else:
+            return False
+
+    def get_vertices(self):
+        return self.vertices.keys()
+
+    def __iter__(self):
+        return iter(self.vertices.values())
+
+# Create a graph with 4 vertices and 5 edges
+graph = Graph()
+for i in range(4):
+    graph.add_vertex(Vertex(i))
+graph.add_edge(0, 1)
+graph.add_edge(0, 2)
+graph.add_edge(1, 2)
+graph.add_edge(1, 3)
+graph.add_edge(2, 3)

Leetcode Daily/Hard/SmallestRangeCoveringElements.py

@@ -0,0 +1,22 @@
+import heapq
+
+
+class Solution:
+  def smallestRange(self, nums: list[list[int]]) -> list[int]:
+    minHeap = [(row[0], i, 0) for i, row in enumerate(nums)]
+    heapq.heapify(minHeap)
+
+    maxRange = max(row[0] for row in nums)
+    minRange = heapq.nsmallest(1, minHeap)[0][0]
+    ans = [minRange, maxRange]
+
+    while len(minHeap) == len(nums):
+      num, r, c = heapq.heappop(minHeap)
+      if c + 1 < len(nums[r]):
+        heapq.heappush(minHeap, (nums[r][c + 1], r, c + 1))
+        maxRange = max(maxRange, nums[r][c + 1])
+        minRange = heapq.nsmallest(1, minHeap)[0][0]
+        if maxRange - minRange < ans[1] - ans[0]:
+          ans[0], ans[1] = minRange, maxRange
+
+    return ans

Leetcode Daily/Medium/DivideIntervalsIntoMinGroups.py

@@ -0,0 +1,13 @@
+from ast import List
+import heapq
+
+class solution:
+    def minGroups(self, intervals: List[List[int]]) -> int:
+        minHeap = []
+
+        for left, right in sorted(intervals):
+            if minHeap and left > minHeap[0]:
+                heapq.heappop(minHeap)
+            heapq.heappush(minHeap, right)
+        
+        return len(minHeap)