Floor and ceil in Binary search tree added

data_structures/binary_tree/floor_ceil_in_bst.py

@@ -0,0 +1,83 @@
+"""
+The floor of a key 'k' in a BST is the maximum
+value that is smaller than or equal to 'k'.
+
+The ceiling of a key 'k' in a BST is the minimum
+value that is greater than or equal to 'k'.
+
+Reference:
+https://bit.ly/46uB0a2
+
+Author : Arunkumar
+Date : 14th October 2023
+"""
+
+
+
+class TreeNode:
+    def __init__(self, key: int):
+        """
+        Initialize a TreeNode with the given key.
+
+        Args:
+            key (int): The key value for the node.
+        """
+        self.key = key
+        self.left: TreeNode | None = None
+        self.right: TreeNode | None = None
+
+
+def floor_ceiling(root: TreeNode | None, key: int) -> tuple[int | None, int | None]:
+    """
+    Find the floor and ceiling values for a given key in a Binary Search Tree (BST).
+
+    Args:
+        root (TreeNode): The root of the BST.
+        key (int): The key for which to find the floor and ceiling.
+
+    Returns:
+        tuple[int | None, int | None]:
+        A tuple containing the floor and ceiling values, respectively.
+
+    Examples:
+        >>> root = TreeNode(10)
+        >>> root.left = TreeNode(5)
+        >>> root.right = TreeNode(20)
+        >>> root.left.left = TreeNode(3)
+        >>> root.left.right = TreeNode(7)
+        >>> root.right.left = TreeNode(15)
+        >>> root.right.right = TreeNode(25)
+        >>> floor, ceiling = floor_ceiling(root, 8)
+        >>> floor
+        7
+        >>> ceiling
+        10
+        >>> floor, ceiling = floor_ceiling(root, 14)
+        >>> floor
+        10
+        >>> ceiling
+        15
+    """
+    floor_val = None
+    ceiling_val = None
+
+    while root is not None:
+        if root.key == key:
+            floor_val = root.key
+            ceiling_val = root.key
+            break
+
+        if key < root.key:
+            ceiling_val = root.key
+            root = root.left
+        else:
+            floor_val = root.key
+            root = root.right
+
+    return floor_val, ceiling_val
+
+
+if __name__ == "__main__":
+    import doctest
+
+    doctest.testmod()

scheduling/shortest_deadline_first.py

@@ -0,0 +1,70 @@
+"""
+Earliest Deadline First (EDF) Scheduling Algorithm
+
+This code implements the Earliest Deadline First (EDF)
+scheduling algorithm, which schedules processes based on their deadlines.
+If a process cannot meet its deadline, it is marked as "Idle."
+
+Reference:
+https://www.geeksforgeeks.org/
+earliest-deadline-first-edf-cpu-scheduling-algorithm/
+
+Author: Arunkumar
+Date: 14th October 2023
+"""
+
+
+def earliest_deadline_first_scheduling(
+    processes: list[tuple[str, int, int, int]]
+) -> list[str]:
+    """
+    Perform Earliest Deadline First (EDF) scheduling.
+
+    Args:
+        processes (List[Tuple[str, int, int, int]]): A list of
+        processes with their names,
+        arrival times, deadlines, and execution times.
+
+    Returns:
+        List[str]: A list of process names in the order they are executed.
+
+    Examples:
+        >>> processes = [("A", 1, 5, 2), ("B", 2, 8, 3), ("C", 3, 4, 1)]
+        >>> execution_order = earliest_deadline_first_scheduling(processes)
+        >>> execution_order
+        ['Idle', 'A', 'C', 'B']
+
+    """
+    result = []
+    current_time = 0
+
+    while processes:
+        available_processes = [
+            process for process in processes if process[1] <= current_time
+        ]
+
+        if not available_processes:
+            result.append("Idle")
+            current_time += 1
+        else:
+            next_process = min(
+                available_processes, key=lambda tuple_values: tuple_values[2]
+            )
+            name, _, deadline, execution_time = next_process
+
+            if current_time + execution_time <= deadline:
+                result.append(name)
+                current_time += execution_time
+                processes.remove(next_process)
+            else:
+                result.append("Idle")
+                current_time += 1
+
+    return result
+
+
+if __name__ == "__main__":
+    processes = [("A", 1, 5, 2), ("B", 2, 8, 3), ("C", 3, 4, 1)]
+    execution_order = earliest_deadline_first_scheduling(processes)
+    for i, process in enumerate(execution_order):
+        print(f"Time {i}: Executing process {process}")