Merge pull request #2 from touunix/Logarithmic-complexity

Add logarithmic complexity tasks

Author: touunix

logarithmic_complexity/__init__.py

@@ -0,0 +1,39 @@
+"""
+Given an array sorted in ascending order and a number k, check that it occurs in
+this array using the half method: first check if the middle element of
+the array = k. If it is smaller than k then continue in the same way looking for k in the
+right half of the array; if it is smaller, then in the left half.
+"""
+from utilities.generator import Generator
+
+
+class Program:
+    @staticmethod
+    def binary_search(search_number: int, array: list) -> bool:
+        left_pointer: int = 0
+        right_pointer: int = len(array) - 1
+
+        while left_pointer <= right_pointer:
+            mid: int = (left_pointer + right_pointer) // 2
+            if array[mid] == search_number:  # look in the middle
+                return True
+            elif array[mid] < search_number:  # look in the left
+                left_pointer: int = mid + 1
+            else:
+                right_pointer: int = mid - 1  # look in the right
+        return False
+
+
+if __name__ == "__main__":
+    input_array: list = Generator.generate_ascending_array()
+    input_search_number: int = Generator.generate_random_search_number()
+
+    print(60 * "-")
+    print(f"Generated random input array: {input_array}")
+    print(60 * "-")
+
+    if Program.binary_search(input_search_number, input_array):
+        print(f"The number: {input_search_number}, is in the array.")
+    else:
+        print(f"The number: {input_search_number}, is not in the array.")
+    print(60 * "-")

logarithmic_complexity/task_1.py

@@ -0,0 +1,68 @@
+"""
+Implement an algorithm for inserting a number into a BST tree, and then write a program which,
+for a given number k, checks whether k occurs in such a tree.
+"""
+from utilities.generator import Generator
+
+
+class TreeNode:
+    def __init__(self, value: int) -> None:
+        self.value: int = value
+        self.left_side: [None | TreeNode] = None
+        self.right_side: [None | TreeNode] = None
+
+
+class BinarySearchTree:
+    def __init__(self) -> None:
+        self._root_node: [None | TreeNode] = None
+
+    def insert(self, value: int) -> None:
+        if not self._root_node:
+            self._root_node = TreeNode(value)  # if the tree is empty, insert the new value
+        else:
+            self._insert_recursively(self._root_node, value)
+
+    def _insert_recursively(self, root_node: TreeNode, value: int) -> None:
+        if value < root_node.value:  # insert on the left side of the root
+            if not root_node.left_side:
+                root_node.left_side = TreeNode(value)
+            else:
+                self._insert_recursively(root_node.left_side, value)
+        else:  # insert on the right side of the root
+            if not root_node.right_side:
+                root_node.right_side = TreeNode(value)
+            else:
+                self._insert_recursively(root_node.right_side, value)
+
+    def search(self, search_number: int) -> bool:
+        return self._search_recursively(self._root_node, search_number) if self._root_node else False
+
+    def _search_recursively(self, root_node: [TreeNode | None], search_number: int) -> bool:
+        if not root_node:  # empty binary tree
+            return False
+        if root_node.value == search_number:
+            return True
+        elif search_number < root_node.value:  # search on the left side of the root
+            return self._search_recursively(root_node.left_side, search_number)
+        else:  # search on the right side of the root
+            return self._search_recursively(root_node.right_side, search_number)
+
+
+if __name__ == "__main__":
+    binary_search_tree = BinarySearchTree()
+    input_search_number: int = Generator.generate_random_search_number()
+    input_numbers: list = Generator.generate_input_array()
+
+    for number in input_numbers:
+        binary_search_tree.insert(number)
+
+    print(60 * "-")
+    print(f"Generated random input search number: {input_search_number}")
+    print(f"Generated random input numbers: {input_numbers}")
+    print(60 * "-")
+
+    if binary_search_tree.search(input_search_number):
+        print(f"The number: {input_search_number} exists in the Binary Search Tree.")
+    else:
+        print(f"The number: {input_search_number} does not exist in the Binary Search Tree.")
+    print(60 * "-")