binary-heap

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))? Stuart Marks 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 O(log n) so inserting n elements results in O(n log n) complexity. This is true if you insert

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 and then apply the union procedure and just make one heap the left child of the other heaps? The key

What are the real world applications of Fibonacci heaps and binary heaps? It'd be great if you could share some instance when you used it to solve a problem. Edit: Added binary heaps also. Curious to know. You would rarely use one in real life. I believe the purpose of the Fibonacci heap was to improve the asymptotic running time of Dijkstra's algorithm. It might give you an improvement for very, very large inputs, but most of the time, a simple binary heap is all you need. From Wiki: Although the total running time of a sequence of operations starting with an empty structure is bounded by the

I can use the std::collections::BinaryHeap to iterate over a collection of a struct in the greatest to least order with pop , but my goal is to iterate over the collection from least to greatest. I have succeeded by reversing the Ord implementation: impl Ord for Item { fn cmp(&self, other: &Self) -> Ordering { match self.offset { b if b > other.offset => Ordering::Less, b if b < other.offset => Ordering::Greater, b if b == other.offset => Ordering::Equal, _ => Ordering::Equal, // ?not sure why compiler needs this } } } Now the BinaryHeap returns the Item s in least to greatest. Seeing as how

quoting Wikipedia : It is perfectly acceptable to use a traditional binary tree data structure to implement a binary heap. There is an issue with finding the adjacent element on the last level on the binary heap when adding an element which can be resolved algorithmically ... Any ideas on how such an algorithm might work? I was not able to find any information about this issue, for most binary heaps are implemented using arrays. Any help appreciated. Recently, I have registered an OpenID account and am not able to edit my initial post nor comment answers. That's why I am responding via this

Consider a binary heap containing n numbers (the root stores the greatest number). You are given a positive integer k < n and a number x. You have to determine whether the kth largest element of the heap is greater than x or not. Your algorithm must take O(k) time. You may use O(k) extra storage Simple dfs can do the job. We have a counter set to zero. Start from the root and in each iteration check the value of current node; if it is greater than x, then increase the counter and continue the algorithm for one of the child nodes. The algorithm terminates if counter is bigger than equal k or if