Per the last posts: Number of heaps: O(n^(1&#x2F;3)). Maximum elements per heap O(n^(2&#x2F;3)).<p>Lookup of an element. Find the heap with the element (i.e. element between maximum of previous heap and this heap). Perform linear search in heap. Worst cast complexity O(n^(1&#x2F;3) + n^(2&#x2F;3)) = O(n^(2&#x2F;3)).<p>Insertion of an element. Find the last heap those maximum element is still larger than the element. Extract top element of the heap and insert the new element instead. Then propagate upwards (i.e. extract top of next heap and insert top of previous heap, etc). Worst case is O(n^(1&#x2F;3) + log(n^(2&#x2F;3)) * n^(1&#x2F;3)) = O(log(n) * n^(1&#x2F;3)).<p>Deletion of an element. Find the heap with the element (i.e. element between maximum of previous heap and this heap). Remove the element from it. Extract top of next heap and insert it into this one. Then continue propagating upwards. So this is O(n^(1&#x2F;3) + n^(2&#x2F;3) + log(n^(2&#x2F;3)) * n^(1&#x2F;3)) = O(n^(2&#x2F;3)).<p>Building the structure. Why is this O(n)? If you have already segregated the array into segments for the separate heaps, heapifying them would be O(n). How can the segmentation be done in O(n)?<p>Edit: Using the suggestion of splitting up according to 1+3+5+..+(2n-1) = n^2 we&#x27;d get:<p>Search: O(sqrt(n) + sqrt(n)) = O(sqrt(n))<p>Insert: O(sqrt(n) + log(sqrt(n)) * sqrt(n)) = O(log(n) * sqrt(n)<p>Delete: O(sqrt(n) + sqrt(n) + log(sqrt(n)) * sqrt(n)) = O(log(n) * sqrt(n))