Completed precourse 2 (couldnt do the iterative run for the quicksort)

[PurvaT-11]

No description provided.

[super30admin]

1. Correctness:

   • Exercise_1.py: The binary search implementation is correct. It correctly handles the search by halving the search space each time.
   • Exercise_2.py: The quicksort implementation is mostly correct but has a bug in the partition function where it uses low and high instead of l and h as parameters. This will cause a runtime error.
   • Exercise_3.py: The linked list middle element finder is correct and efficiently uses the slow and fast pointer technique.
   • Exercise_4.py: The merge sort implementation is correct and follows the standard divide-and-conquer approach.
   • Exercise_5.py: The iterative quicksort is incomplete and missing the main logic for the iterative approach. The partition function also has the same bug as in Exercise_2.py.

2. Time Complexity:

   • Exercise_1.py: Correctly noted as O(log n).
   • Exercise_2.py: Correctly noted as O(n^2) in the worst case and O(n log n) in the average case.
   • Exercise_3.py: Correctly noted as O(n).
   • Exercise_4.py: Correctly noted as O(n log n).
   • Exercise_5.py: Not applicable due to incomplete implementation.

3. Space Complexity:

   • Exercise_1.py: Correctly noted as O(log n) due to recursive stack space, but the implementation is iterative, so it should be O(1).
   • Exercise_2.py: Correctly noted as O(n) due to recursive stack space.
   • Exercise_3.py: Correctly noted as O(1) for finding the middle element.
   • Exercise_4.py: Correctly noted as O(n) for the merge step.
   • Exercise_5.py: Not applicable due to incomplete implementation.

4. Code Quality:

   • The code is generally well-structured and readable. Variable names are meaningful, and comments are helpful.
   • The bug in the partition function (using low and high instead of l and h) is a significant issue that needs to be fixed.
   • The iterative quicksort implementation is incomplete, which is a major gap.

5. Efficiency:

   • The binary search and merge sort implementations are efficient and follow best practices.
   • The quicksort implementations could be improved by fixing the partition function bug and completing the iterative version.