KHAZZANI-Badr-TP-Tri

sort/fusion.py

@@ -1,2 +1,43 @@
-def sort(array: list[int]) -> list[int]:
-    return array
+from typing import List
+import time
+import range as range_array
+
+def main():
+    '''Function to evaluate the algorithm complexity'''
+    for size in range(1, 11):
+        array: List[int] = range_array.generate_array_of_number(size * 1000)
+        start_time: float = time.time()
+        sort(array)
+        end_time: float = time.time()
+        print("Taille de tableau : ", size * 1000,
+              " Temps écoulé :", end_time - start_time)
+
+def sort(array: List[int]) -> List[int]:
+    if len(array) <= 1:
+        return array
+
+    separation: int = len(array) // 2
+    array1: List[int] = array[:separation]
+    array2: List[int] = array[separation:]
+
+    return merge(sort(array1), sort(array2))
+
+def merge(array1: List[int], array2: List[int]) -> List[int]:
+    result_array: List[int] = []
+    i = j = 0
+
+    while i < len(array1) and j < len(array2):
+        if array1[i] < array2[j]:
+            result_array.append(array1[i])
+            i += 1
+        else:
+            result_array.append(array2[j])
+            j += 1
+
+    result_array.extend(array1[i:])
+    result_array.extend(array2[j:])
+
+    return result_array
+
+if __name__ == "__main__":
+    main()

sort/insertion.py

@@ -1,2 +1,30 @@
-def sort(array: list[int]) -> list[int]:
+import time
+from typing import List
+import range as range_array 
+# Assuming you have a module named 'range_array' for generating arrays
+
+def main():
+    '''Function to evaluate the algorithm complexity'''
+    for size in range(1, 11):
+        array: List[int] = range_array.generate_array_of_number(size * 1000)
+        start_time: float = time.time()
+        sort(array)
+        end_time: float = time.time()
+        print("Taille de tableau : ", size * 1000,
+              " Temps écoulé :", end_time - start_time)
+
+def sort(array: List[int]) -> List[int]:
+    for old_index in range(1, len(array)):
+        current_value = array[old_index]
+        index_to_place = old_index - 1
+
+        while index_to_place >= 0 and current_value < array[index_to_place]:
+            array[index_to_place + 1] = array[index_to_place]
+            index_to_place -= 1
+
+        array[index_to_place + 1] = current_value
+
     return array
+
+if __name__ == "__main__":
+    main()

sort/range.py

@@ -1,2 +1,19 @@
+import random
+import time
+
+def main():
+    '''Function to evaluate the algorithm complexity'''
+    for size in range(1, 11):
+        start_time = time.time()
+        array_size = size * 1_000_000
+        generate_array_of_number(array_size)
+        end_time = time.time()
+        print("Taille de tableau : ", array_size,
+              " Temps écoulé :", end_time - start_time)
+
 def generate_array_of_number(array_size: int) -> list[int]:
-    return []
+    """Generate an array of random numbers."""
+    return [random.randint(0, 100) for _ in range(array_size)]
+
+if __name__ == "__main__":
+    main()

sort/recursion.py

@@ -1,2 +1,5 @@
-def get_factorial(number: int) -> int:
-    return number
+def get_factorial_iterative(number: int) -> int:
+    result = 1
+    for i in range(1, number + 1):
+        result *= i
+    return result

sort/selection.py

@@ -1,2 +1,34 @@
-def sort(array: list[int]) -> list[int]:
+import time
+from typing import List
+import range as range_array
+
+def main():
+    '''Function to evaluate the algorithm complexity'''
+    for size in range(1, 11):
+        array: List[int] = range_array.generate_array_of_number(size * 1000)
+        start_time: float = time.time()
+        sort(array)
+        end_time: float = time.time()
+        print("Taille de tableau : ", size * 1000,
+              " Temps écoulé :", end_time - start_time)
+
+def sort(array: List[int]) -> List[int]:
+    '''Selection sort algorithm'''
+
+    for iterator in range(len(array)):
+        min_index = find_min_index(array, iterator)
+        array[iterator], array[min_index] = array[min_index], array[iterator]
+
     return array
+
+def find_min_index(array: List[int], start_index: int) -> int:
+    min_index = start_index
+
+    for index in range(start_index, len(array)):
+        if array[index] < array[min_index]:
+            min_index = index
+
+    return min_index
+
+if __name__ == "__main__":
+    main()