Explanation:

Insertion sort has the worst-case time complexity of O(n^2). Let's understand why.

Insertion Sort:
Insertion sort is a simple sorting algorithm that builds the final sorted array one item at a time. It is based on the idea that one element from the input elements is consumed in each iteration to find its correct position in the sorted array.

Worst Case:
The worst-case scenario occurs when the input array is in reverse order. In this case, for each element, the algorithm needs to compare it with all the previous elements in the sorted part of the array and shift them if they are greater, until it finds the correct position for the current element.

Key Steps:
The key steps involved in insertion sort are as follows:

1. Iterate through the array from the second element to the last element.
2. For each element, compare it with all the previous elements in the sorted part of the array.
3. If the current element is smaller than any of the previous elements, shift those elements to the right to create space for the current element.
4. Insert the current element at its correct position in the sorted part of the array.

Time Complexity Analysis:
To analyze the time complexity of insertion sort, we need to count the number of comparisons and shifts performed.

Comparisons:
In the worst-case scenario, for each element at index i, we need to compare it with all the previous elements in the sorted part of the array (from index 0 to i-1). So, the total number of comparisons can be calculated as follows:

n-1 + n-2 + n-3 + ... + 1 = (n-1) * n / 2 = (n^2 - n) / 2

Shifts:
In the worst-case scenario, for each element at index i, we may need to shift all the previous elements in the sorted part of the array (from index 0 to i-1) to the right. So, the total number of shifts can be calculated as follows:

n-1 + n-2 + n-3 + ... + 1 = (n-1) * n / 2 = (n^2 - n) / 2

Total Time Complexity:
The total number of comparisons and shifts can be calculated by summing up the above two expressions. Simplifying the expression, we get:

(n^2 - n) / 2 + (n^2 - n) / 2 = (2n^2 - 2n) / 2 = n^2 - n

Therefore, the worst-case time complexity of insertion sort is O(n^2).

Conclusion:
Among the given sorting algorithms, insertion sort has the worst-case time complexity of O(n^2). This means that as the size of the input array increases, the time taken by the algorithm to sort the array increases quadratically. It is not as efficient as other sorting algorithms like merge sort (O(nlogn)), quick sort (O(nlogn)), or heap sort (O(nlogn)) in terms of time complexity.