adding pre-course2 solutions

[nikhylw]

No description provided.

[super30admin]

Exercise_1 (Binary Search):

• Correctness: The iterative binary search implementation is correct. It properly handles the search space reduction and handles the case when the element is not found.
• Time Complexity: O(log n) - optimal for sorted array search.
• Space Complexity: O(1) - constant space as it uses only a few variables.
• Code Quality: Clean and readable with good comments explaining the approach.

Exercise_2 (Quick Sort):

• Correctness: Standard Lomuto partition scheme implementation is correct. The algorithm properly partitions and recursively sorts subarrays.
• Time Complexity: O(n log n) average case, O(n²) worst case (when pivot is always min/max).
• Space Complexity: O(log n) for recursion stack (worst case O(n)).
• Code Quality: Well-structured with clear separation between partition and quickSort functions.

Exercise_3 (Linked List Middle Element):

• Correctness: Classic two-pointer technique (slow and fast pointers) is correctly implemented to find the middle element.
• Time Complexity: O(n) - single pass through the list.
• Space Complexity: O(1) - constant space.
• Code Quality: Good OOP structure with separate Node and LinkedList classes. Could benefit from edge case handling for empty lists (though the code does check for None).

Exercise_4 (Merge Sort):

• Correctness: Standard top-down merge sort implementation is correct. The merge function properly combines two sorted halves.
• Time Complexity: O(n log n) - guaranteed for all cases.
• Space Complexity: O(n) - requires auxiliary arrays for left and right halves during each recursion level.
• Code Quality: Well-documented with clear comments. The printList helper function adds readability.

Exercise_5 (Iterative Quick Sort):

• Correctness: Correct implementation of iterative quicksort using an explicit stack to simulate recursion. The partition logic is identical to Exercise_2.
• Time Complexity: O(n log n) average case, O(n²) worst case.
• Space Complexity: O(log n) for the stack (explicit stack replaces recursion stack).
• Code Quality: Good implementation, though the stack management code is slightly verbose. Could be simplified with helper function or more concise logic.

General Observations:

• All exercises demonstrate solid understanding of fundamental algorithms and data structures.
• Code is well-commented and follows Python conventions.
• Edge case handling could be improved in some exercises (e.g., empty arrays, single elements).
• The iterative approaches (Exercises 1 and 5) show good understanding of avoiding recursion depth issues.