### Performance of Sorting Algorithms on Sorted and Unsorted Data Sorting is a fundamental operation in algorithm design, and the performance of a sorting algorithm depends significantly on the initial arrangement of the input data. In an Algorithm Design Lab, comparing sorting algorithms on sorted and unsorted data helps in understanding time complexity, best-case and worst-case behaviour, number of comparisons, number of swaps, and practical execution time. Common sorting algorithms such as Bubble Sort, Selection Sort, Insertion Sort, Merge Sort, and Quick Sort show different performance characteristics when the input is already sorted compared with when the input is completely unsorted. Bubble Sort repeatedly compares adjacent elements and exchanges them when they are in the wrong order. For an unsorted array, Bubble Sort generally requires (O(n^2)) comparisons and swaps in the average and worst cases. Therefore, its performance decreases rapidly as the size of the input increases. If an optimized version of Bubble Sort is used, the algorithm can detect whether any swap occurred during a pass. For already sorted data, no swaps are required, and the algorithm can terminate after the first pass. Thus, its best-case time complexity becomes (O(n)). For example, for the array 1, 2, 3, 4, 5, Bubble Sort only needs to check the adjacent elements and can stop immediately. In contrast, an unsorted array such as 5, 1, 4, 2, 3 requires several passes and many exchanges. Hence, Bubble Sort benefits considerably from sorted input when an early-termination condition is implemented. Selection Sort works by finding the smallest element from the unsorted portion of the array and placing it at the correct position. Unlike Bubble Sort, Selection Sort performs almost the same number of comparisons regardless of whether the input is sorted or unsorted. Its time complexity is (O(n^2)) in the best, average, and worst cases. Even when the input is already sorted, Selection Sort continues scanning the remaining elements to identify the minimum element. Therefore, sorted data does not provide a significant time advantage. Its main benefit is that it performs relatively few swaps, generally at most (O(n)). For unsorted data, it also requires (O(n^2)) comparisons. Consequently, Selection Sort is simple to implement but is inefficient for large datasets. Insertion Sort has a particularly important advantage when the input is already sorted or nearly sorted. It builds the sorted array one element at a time by inserting each new element into its appropriate position. For completely sorted data, every element is already in its correct position. Therefore, only one comparison is generally required for each element, resulting in a best-case time complexity of (O(n)). For unsorted data, elements may need to be