Python Error Checking and Sorting Algorithms

What is the time complexity of a bubble sort in the best case scenario?

Which sorting algorithm is considered stable?

Which of the following data structures allows you to change an index without error?

What is the worst-case time complexity of a binary search?

What can you infer about the space complexity of sorting algorithms mentioned?

For which type of data is insertion sort particularly efficient?

If you have a variable called 'My_variable', which of the following would likely result in an error in Python?

Which algorithm has the fastest time complexity among the sorting algorithms discussed?

Insertion sort has a worst case time complexity of O(n)

Bubble sort is not stable and is poor for large datasets.

All sorting algorithms mentioned have a space complexity of O(1).

Linear search requires a sorted dataset to function correctly.

The time complexity of a binary search is better than that of a linear search in all cases.

Selection sort has a best case time complexity of O(n).

Stability in sorting algorithms means the relative order of equal elements is maintained.

A tuple's index can be changed without causing an error.

Python Error Checking

Check if variable names are valid:
- Case-sensitive
- Not a Python keyword
- No spaces, commas, or symbols
- Cannot start with a digit

Lab 4: List Operations

Inserting at the back has a constant time complexity (O(1))
Inserting at the front has a linear time complexity (O(n))
Big O notations: O(1) , O(log n), O(n), O(n log n), O(n^2), O(2^n), O(n!)

Lab 6: Sorting Algorithms

Bubble Sort:
- Compares adjacent elements and swaps if needed.
- Best case: O(n)
- Worst/Average case: O(n^2)
Selection Sort:
- Finds the minimum element and swaps it to the correct position.
- All cases: O(n^2)
Insertion Sort:
- Builds a sorted array progressively by comparing the current element with elements in the already sorted part.
- Best case: O(n)
- Worst/Average case: O(n^2)
Space Complexity: All sorting algorithms have a space complexity of O(1) (in-place)
Algorithm Comparisons:
- Insertion Sort: Good for small or nearly sorted arrays.
- Bubble Sort: Inefficient for large datasets.
- Selection Sort: Inefficient in all cases.
Merge Sort:
- O(n log n) - fastest among these.
Stability:
- Bubble and Insertion sorts are stable
- Selection sort is not stable
Adaptability:
- Insertion sort is adaptable to nearly sorted datasets
- Bubble sort is somewhat adaptable
- Selection sort is not adaptable

Lab 7: Indexing

Remember array index starts at 0 and ends at length-1

Lab 8: Linear Search

Linear Search/Sequential Search: Checks each element sequentially until the target is found.
Sorted or unsorted data can be searched
Time complexity: O(n)

Lab 9: Binary Search

Binary Search: Requires a sorted array; repeatedly divides the search interval in half.
Time complexity: O(log₂n) - binary logarithm

Lab 10: Tuple Immutability

Tuples are immutable; you cannot change their elements.
Modifying a tuple index will cause an error

Lab 11: Variable Identity

c = a creates a new variable c but pointing to the same object as a
d = a[:] creates a copy of a (a new list)

Lab 12: List Sorting Methods

list.sort(): Modifies the original list (in-place).
sorted(list): Creates a new sorted list without modifying the original.

This quiz covers essential concepts in Python, focusing on error checking for variable names and various sorting algorithms. Participants will explore the complexities of operations like insertion and sorting methods, including Bubble, Selection, and Insertion Sort. Test your understanding of these critical programming topics!