binary-heap

问题 I have been struggling with this for several hours now, and I can't seem to find the answers here either. (there are many posts about Binary Heap, but I did not this particular problem). The problem is: For a Binary Heap with 1492 nodes, the number of nodes of height two is _ 187 _. I understand that with 1492 nodes, the binary heap has the depth log(1492)/log(2) = 10 height two should have 2^(10-2) nodes which should be 256 Why is the answer 187? Thank you 回答1: In case someone needs to know.

问题 In a (max) heap it is easy to find the biggest item in O(1) time, but to actually remove it you need complexity of O(log(n)) . So if the insertion and deletion from a heap is both O(log(n)) , what are the advantages of a heap over binary tree for representing a priority queue? 回答1: Heaps use less memory. They can be implemented as arrays and thus there is no overhead for storing pointers. (A binary tree CAN be implemented as an array, but there is likely to be many empty "gaps" which could

问题 I think that I know the answer and the minimum complexity is O(nlogn) . But is there any way that I can make an binary search tree from a heap in O(n) complexity? 回答1: There is no algorithm for building a BST from a heap in O(n) time. The reason for this is that given n elements, you can build a heap from them in O(n) time. If you have a BST for a set of values, you can sort them in O(n) time by doing an inorder traversal. If you could build a BST from a heap in O(n) time, you could then have

问题 I am trying to prove that for binary heaps, buildHeap does at most (2N-2) comparisons between elements. I find it very difficult to prove this claim. 回答1: The build-heap algorithm starts at the midpoint and moves items down as required. Let's consider a heap of 127 items (7 levels). In the worst case: 64 nodes (the leaf level) don't move at all 32 nodes move down one level 16 nodes move down two levels 8 nodes move down three levels 4 nodes move down four levels 2 nodes move down five levels

问题 This is one of the interview questions I recently came across. Given the root address of a complete or almost complete binary tree, we have to write a function to convert the tree to a max-heap. There are no arrays involved here. The tree is already constructed. For e.g., 1 / \ 2 5 / \ / \ 3 4 6 7 can have any of the possible max heaps as the output-- 7 / \ 3 6 / \ / \ 2 1 4 5 or 7 / \ 4 6 / \ / \ 2 3 1 5 etc... I wrote a solution but using a combination of pre and post order traversals but

问题 In my program I need to delete an element from a priority queue that is not at the top. Can that be done? If not, please suggest a way to do so except creating your own heap. 回答1: The standard priority_queue<T> can be customized through inheritance. It has protected members c and comp that can be referenced in a descendant class. template<typename T> class custom_priority_queue : public std::priority_queue<T, std::vector<T>> { public: bool remove(const T& value) { auto it = std::find(this->c

问题 What is the complexity of Java's PriorityQueue constructor with a Collection ? I used the constructor: PriorityQueue(Collection<? extends E> c) Is the complexity O(n) or O(n*log(n))? 回答1: The time complexity to initialize a PriorityQueue from a collection, even an unsorted one, is O(n). Internally this uses a procedure called siftDown() to "heapify" an array in-place. (This is also called pushdown in the literature.) This is counterintuitive. It seems like inserting an element into a heap is

问题 I need to know the main difference between binary and binomial heaps regardless of the their structure difference that binary heaps can have only two child (tree representation) and binomial heaps can have any number of children. I am actually just wondering that what so special in organizing the binomial tree structure in such a way that the first child have on one node second have two third have four and so on? What if, if we use some normal tree for heaps without restriction of two child

问题 In Weiss 'Data Structures and Algorithms In Java", he explains the insert algorithm for binary heaps thusly public void insert( AnyType x ) { if( currentSize == array.length -1) enlargeArray( array.length * 2 + 1); // Percolate up int hole = ++currentSize; for(array[0] = x; x.compareTo( array[ hole / 2 ]) < 0; hole /=2 ) array[ hole ] = array[ hole / 2 ]; array[ hole ] = x; } I get the principle of moving a hole up the tree, but I don't understand how he's accomplishing it with this syntax in

问题 In a binary max heap implemented as a binary tree (where each node stores a pointer to its parent, left child, and right child), if you have the pointer to the root of the heap, how would you implement an insert operation? What's supposed to happen is the node first gets inserted as the last element in the last row. For array based, you could append to the array, but for tree based implementation, how would you find the right spot? 回答1: In this older question, I gave a short algorithm that