heap data structure complexity
Even if i don't really understand your point, i'm try to figure out an intuitive proof for building heap time complexity, starting from a simple recursive algorithm for building heap.

You have a collection of n unsorted element, called A,
you want from this collection build a heap(in your case a min-heap because you are mantaining the minimum of collection in the root).

So modelling the heap you want to create like a binary tree, it must shows some property like:


complete: the tree is "fullfilled" until second-last level and the leaves are "compatted" on the left.
logarithmic height: if the number in the heap is n then the height is O(logn) (you can proof this starting from the first property)
order relation between nodes: in particular, if v is father of w in the tree then $$ value(v)&lt;= value(w) $$


Now think A as an unsorted binary tree you can recursively construct an heap follows this step:


Make recursive call on the left sub-tree
Make recursive call on the right sub-tree
Call heapify on the root of the current tree


heapify

Heapify on a node v simply compare v with it sons, and exchange v with the lowest son if it is less than v. Do this repeatedly until exists a son of v that have less value.

heapify complexity

So in heapify you make, at most, as many exchanges as high as the tree is, and since the only operation you perform is compare with the son(at most 2) for each level

=> time complexity is O(logn) for the 2nd property.

now for compute the overall complexity you can set a recursion function considering the worst case in wich A is a perfect binary tree (complete and with last level  fullfilled).

So let's assume A is a perfect binary tree,
the recursion function is: 

$$ T(n) = T((n-1)/2) + O(log(n)) $$

because in each recursion step you consider half-part of the tree and exclude the root, and in each step with n as parameter you pay $$ O(log(n))$$ for heapify.

So by Master theorem (https://en.wikipedia.org/wiki/Master_theorem_(analysis_of_algorithms)) 

$$T(n) = O(n) $$

so you can deduce that building an heap from an unsorted collection of value is linear in the number of element in the collection.

Know this maybe don't answer your question but i hope can help!