Why is it impossible to convert a Min Heap to a Binary Search Tree (BST) in O(n) time?

I'm working on formally proving that it's impossible to convert a Min Heap into a BST in O(n) time complexity.

My reasoning is that any algorithm attempting this conversion would need to perform comparisons to sort each level of the heap, as the elements within each level are not inherently sorted. Since comparison-based sorting algorithms have a known lower bound of O(nlogn) time complexity, this suggests that the overall time complexity of converting a Min Heap to a BST would also be at least O(nlogn), not O(n).

How can I effectively explain or prove this? Alternatively, if my reasoning is flawed, what is the correct explanation for why this conversion cannot be done in O(n) time?

Yes, your analysis is correct.

Let's suppose the contrary is true, and that you can convert any Min Heap into a BST with O(𝑛) time complexity. Then you would have the ingredients to sort a list of values with a O(𝑛) time complexity:

1. Create a Min Heap from the list of values. This can be done with O(𝑛) time complexity.
2. Turn this into a BST with the supposed algorithm having O(𝑛) time complexity.
3. Perform an inorder traversal of this BST to retrieve a sorted list. This has O(𝑛) time complexity.

And then O(𝑛+𝑛+𝑛) is O(𝑛). But this is not possible, as a comparison based sorting algorithm has a worst case time complexity of Ω(𝑛log𝑛).

A proof of this is found at Wikipedia at Number of comparisons required to sort a list:

Given a list of distinct numbers (we can assume this because this is a worst-case analysis), there are 𝑛 factorial permutations exactly one of which is the list in sorted order. The sort algorithm must gain enough information from the comparisons to identify the correct permutation. If the algorithm always completes after at most 𝑓(𝑛) steps, it cannot distinguish more than 2^𝑓(𝑛) cases because the keys are distinct and each comparison has only two possible outcomes. Therefore,

      2^𝑓(𝑛) ≥ 𝑛!, or equivalently 𝑓(𝑛) ≥ log₂(𝑛!).

By looking at the first 𝑛/2 factors of 𝑛! = 𝑛(𝑛−1)⋅⋅⋅1, we obtain

      log₂(𝑛!) ≥ log₂((𝑛/2)^𝑛/2) = (𝑛/2)(log𝑛/log2)−𝑛/2 = Θ(𝑛log𝑛).

      log₂(𝑛!) = Ω(𝑛log𝑛).

Conclusion: the assumption cannot be true, and so a Min Heap cannot be converted into a BST with a worst-case time complexity of O(𝑛).