|
|
| (One intermediate revision by one other user not shown) |
| Line 1: |
Line 1: |
| {{no footnotes|date=March 2013}}
| | Do you know that you may save a great deal of money by utilizing the proper promo code when making a purchase order? These codes are provided by many retailers and you might want to key them into a particular subject when making a purchase order on the company's website. As a matter of truth, a number of folks by no means shop except they get some type of low cost or the opposite or at the very least free shipping. |
| In [[computer science]], a '''binomial heap''' is a [[Heap (data structure)|heap]] similar to a [[binary heap]] but also supports quick merging of two heaps. This is achieved by using a special tree structure. It is important as an implementation of the [[mergeable heap]] [[abstract data type]] (also called [[meldable heap]]), which is a [[priority queue]] supporting merge operation.
| |
|
| |
|
| ==Binomial tree==
| | The following tips will provide help to save quite a bit of money yearly by helping you utilize low cost codes correctly: - Maximize the low cost through the use of a number of codes on the identical product if this is possible. For example, you need to use a discount coupon along with one that offers free transport or another tangible benefit. If you're really fortunate you also needs to have the ability to use the low cost code on a product that is already marked down very much. |
| A binomial heap is implemented as a collection of [[binomial]] [[tree data structure|tree]]s (compare with a [[binary heap]], which has a shape of a single [[binary tree]]). A '''binomial tree''' is defined recursively:
| |
|
| |
|
| * A binomial tree of order 0 is a single node
| | It's essential search for these offers and your exhausting work will probably be rewarded. - Purchase in bulk with a view to reap the benefits of the most attractive coupons. This should not be a problem if it's important to purchase non-perishables akin to toilet rolls, detergent etc. If the supply is on raw meals then you must assume twice since you might need to course of them appropriately before you may store them. Another option is to get one other person to pool purchases with you so that you do not have to deal with a storage emergency. |
| * A binomial tree of order ''k'' has a root node whose children are roots of binomial trees of orders ''k''−1, ''k''−2, ..., 2, 1, 0 (in this order).
| |
|
| |
|
| [[Image:Binomial Trees.svg|center|thumb|500px|Binomial trees of order 0 to 3: Each tree has a root node with subtrees of all lower ordered binomial trees, which have been highlighted. For example, the order 3 binomial tree is connected to an order 2, 1, and 0 (highlighted as blue, green and red respectively) binomial tree.]]
| | - Get the newest data on all of the codes obtainable at any level of time. Only then will you be capable of use them effectively. If you have any issues about exactly where and how to use [http://www.ogahrugi.com/ promo kartu kredit], you can contact us at our site. One option to get the correct information is by 'liking' or 'following' a retailer on a social networking site. The company will reward you by sending you all its newest promo codes. You would possibly even get special provides which are distributed solely on social networking sites. |
|
| |
|
| A binomial tree of order ''k'' has 2<sup>k</sup> nodes, height ''k''.
| | It is also a good suggestion to have a network of likeminded individuals who you possibly can share codes with and get good ones in return. If you are a wise shopper it is possible for you to to find the suitable promo code for almost every part you want to purchase, enabling you to avoid wasting thousands of dollars a year. Needless to say you may get the codes you want completely without spending a dime as long as you are keen to put in some effort to locate them. |
| | |
| Because of its unique structure, a binomial tree of order ''k'' can be constructed from two trees of order ''k''−1 trivially by attaching one of them as the leftmost child of root of the other one. This feature is central to the ''merge'' operation of a binomial heap, which is its major advantage over other conventional heaps.
| |
| | |
| The name comes from the shape: a binomial tree of order <math>n</math> has <math>\tbinom n d</math> nodes at depth <math>d</math>. (See [[Binomial coefficient]].)
| |
| | |
| ==Structure of a binomial heap==
| |
| A binomial heap is implemented as a set of binomial trees that satisfy the ''binomial heap properties'':
| |
| | |
| * Each binomial tree in a heap obeys the ''[[minimum-heap property]]'': the key of a node is greater than or equal to the key of its parent.
| |
| | |
| * There can only be either ''one'' or ''zero'' binomial trees for each order, including zero order.
| |
| | |
| The first property ensures that the root of each binomial tree contains the smallest key in the tree, which applies to the entire heap.
| |
| | |
| The second property implies that a binomial heap with ''n'' nodes consists of at most [[Binary logarithm|log]] ''n'' + 1 binomial trees. In fact, the number and orders of these trees are uniquely determined by the number of nodes ''n'': each binomial tree corresponds to one digit in the [[binary numeral system|binary]] representation of number ''n''. For example number 13 is 1101 in binary, <math>2^3 + 2^2 + 2^0</math>, and thus a binomial heap with 13 nodes will consist of three binomial trees of orders 3, 2, and 0 (see figure below).
| |
| | |
| <center>[[Image:Binomial-heap-13.svg|325px|Example of a binomial heap]]<br>''Example of a binomial heap containing 13 nodes with distinct keys.<br/>The heap consists of three binomial trees with orders 0, 2, and 3.''</center>
| |
| | |
| ==Implementation==
| |
| Because no operation requires random access to the root nodes of the binomial trees, the roots of the binomial trees can be stored in a [[linked list]], ordered by increasing order of the tree.
| |
| | |
| ===Merge===
| |
| As mentioned above, the simplest and most important operation is the merging of two binomial trees of the same order within two binomial heaps. Due to the structure of binomial trees, they can be merged trivially. As their root node is the smallest element within the tree, by comparing the two keys, the smaller of them is the minimum key, and becomes the new root node. Then the other tree becomes a subtree of the combined tree. This operation is basic to the complete merging of two binomial heaps.
| |
| | |
| '''function''' mergeTree(p, q)
| |
| '''if''' p.root.key <= q.root.key
| |
| '''return''' p.addSubTree(q)
| |
| '''else'''
| |
| '''return''' q.addSubTree(p)
| |
| | |
| [[Image:Binomial heap merge1.svg|left|thumb|200px|To merge two binomial trees of the same order, first compare the root key. Since 7>3, the black tree on the left(with root node 7) is attached to the grey tree on the right(with root node 3) as a subtree. The result is a tree of order 3.]]
| |
| | |
| The operation of '''merging''' two heaps is perhaps the most interesting and can be used as a subroutine in most other operations. The lists of roots of both heaps are traversed simultaneously, similarly as in the [[merge algorithm]].
| |
| | |
| If only one of the heaps contains a tree of order ''j'', this tree is moved to the merged heap. If both heaps contain a tree of order ''j'', the two trees are merged to one tree of order ''j''+1 so that the minimum-heap property is satisfied. Note that it may later be necessary to merge this tree with some other tree of order ''j''+1 present in one of the heaps. In the course of the algorithm, we need to examine at most three trees of any order (two from the two heaps we merge and one composed of two smaller trees).
| |
| | |
| Because each binomial tree in a binomial heap corresponds to a bit in the binary representation of its size, there is an analogy between the merging of two heaps and the binary addition of the ''sizes'' of the two heaps, from right-to-left. Whenever a carry occurs during addition, this corresponds to a merging of two binomial trees during the merge.
| |
| | |
| Each tree has order at most log ''n'' and therefore the running time is ''O''(log ''n'').
| |
| | |
| '''function''' merge(p, q)
| |
| '''while''' '''not''' (p.end() '''and''' q.end())
| |
| tree = mergeTree(p.currentTree(), q.currentTree())
| |
|
| |
| '''if''' '''not''' heap.currentTree().empty()
| |
| tree = mergeTree(tree, heap.currentTree())
| |
|
| |
| heap.addTree(tree)
| |
| heap.next(); p.next(); q.next()
| |
| | |
| [[Image:Binomial heap merge2.svg|right|thumb|300px|This shows the merger of two binomial heaps. This is accomplished by merging two binomial trees of the same order one by one. If the resulting merged tree has the same order as one binomial tree in one of the two heaps, then those two are merged again.]]
| |
| | |
| ===Insert===
| |
| '''Inserting''' a new element to a heap can be done by simply creating a new heap containing only this element and then merging it with the original heap. Due to the merge, insert takes O(log ''n'') time,however it has an ''amortized'' time of O(1) (i.e. constant).
| |
| | |
| ===Find minimum===
| |
| To find the '''minimum''' element of the heap, find the minimum among the roots of the binomial trees. This can again be done easily in ''O''(log ''n'') time, as there are just ''O''(log ''n'') trees and hence roots to examine.
| |
| | |
| By using a pointer to the binomial tree that contains the minimum element, the time for this operation can be reduced to ''O''(1). The pointer must be updated when performing any operation other than Find minimum. This can be done in ''O''(log ''n'') without raising the running time of any operation.
| |
| | |
| ===Delete minimum===
| |
| To '''delete the minimum element''' from the heap, first find this element, remove it from its binomial tree, and obtain a list of its subtrees. Then transform this list of subtrees into a separate binomial heap by reordering them from smallest to largest order. Then merge this heap with the original heap. Since each tree has at most log ''n'' children, creating this new heap is ''O''(log ''n''). Merging heaps is ''O''(log ''n''), so the entire delete minimum operation is ''O''(log ''n'').
| |
| | |
| '''function''' deleteMin(heap)
| |
| min = heap.trees().first()
| |
| '''for each''' current '''in''' heap.trees()
| |
| '''if''' current.root < min '''then''' min = current
| |
| '''for each''' tree '''in''' min.subTrees()
| |
| tmp.addTree(tree)
| |
| heap.removeTree(min)
| |
| merge(heap, tmp)
| |
| | |
| ===Decrease key===
| |
| After '''decreasing''' the key of an element, it may become smaller than the key of its parent, violating the minimum-heap property. If this is the case, exchange the element with its parent, and possibly also with its grandparent, and so on, until the minimum-heap property is no longer violated. Each binomial tree has height at most log ''n'', so this takes ''O''(log ''n'') time.
| |
| | |
| ===Delete===
| |
| To '''delete''' an element from the heap, decrease its key to negative infinity (that is, some value lower than any element in the heap) and then delete the minimum in the heap.
| |
| | |
| ==Performance==
| |
| All of the following operations work in [[Big O notation|O]](log ''n'') time on a binomial heap with ''n'' elements:
| |
| | |
| * Insert a new element to the heap
| |
| * Find the element with minimum key
| |
| * Delete the element with minimum key from the heap
| |
| * Decrease key of a given element
| |
| * Delete given element from the heap
| |
| * Merge two given heaps to one heap
| |
| | |
| Finding the element with minimum key can also be done in ''O''(1) by using an additional pointer to the minimum.
| |
| | |
| ==Applications==
| |
| * [[Discrete event simulation]]
| |
| * [[Priority queue]]s
| |
| | |
| ==See also==
| |
| * [[Fibonacci heap]]
| |
| * [[Soft heap]]
| |
| * [[Skew binomial heap]]
| |
| | |
| ==References==
| |
| * [[Thomas H. Cormen]], [[Charles E. Leiserson]], [[Ronald L. Rivest]], and [[Clifford Stein]]. ''[[Introduction to Algorithms]]'', Second Edition. MIT Press and McGraw-Hill, 2001. ISBN 0-262-03293-7. Chapter 19: Binomial Heaps, pp. 455–475.
| |
| * Vuillemin, J. (1978). [http://portal.acm.org/citation.cfm?id=359478 A data structure for manipulating priority queues.] ''Communications of the ACM'' '''21''', 309–314.
| |
| | |
| ==External links==
| |
| <!-- * [http://es.wikipedia.org/wiki/Heap_Binomial Binomial Heaps (Spanish)] This is in wikidata and on the left handsite with all other iw-links-->
| |
| * [http://www.cs.yorku.ca/~aaw/Sotirios/BinomialHeap.html Java applet simulation of binomial heap]
| |
| * [http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/511508 Python implementation of binomial heap]
| |
| * [http://www.cs.unc.edu/~bbb/#binomial_heaps Two C implementations of binomial heap] (a generic one and one optimized for integer keys)
| |
| * [http://hackage.haskell.org/packages/archive/TreeStructures/latest/doc/html/src/Data-Heap-Binomial.html Haskell implementation of binomial heap]
| |
| * [https://github.com/vy/binomial-heap Common Lisp implementation of binomial heap]
| |
| | |
| {{Data structures}}
| |
| | |
| [[Category:Heaps (data structures)]]
| |
| | |
| {{Link GA|de}}
| |
Do you know that you may save a great deal of money by utilizing the proper promo code when making a purchase order? These codes are provided by many retailers and you might want to key them into a particular subject when making a purchase order on the company's website. As a matter of truth, a number of folks by no means shop except they get some type of low cost or the opposite or at the very least free shipping.
The following tips will provide help to save quite a bit of money yearly by helping you utilize low cost codes correctly: - Maximize the low cost through the use of a number of codes on the identical product if this is possible. For example, you need to use a discount coupon along with one that offers free transport or another tangible benefit. If you're really fortunate you also needs to have the ability to use the low cost code on a product that is already marked down very much.
It's essential search for these offers and your exhausting work will probably be rewarded. - Purchase in bulk with a view to reap the benefits of the most attractive coupons. This should not be a problem if it's important to purchase non-perishables akin to toilet rolls, detergent etc. If the supply is on raw meals then you must assume twice since you might need to course of them appropriately before you may store them. Another option is to get one other person to pool purchases with you so that you do not have to deal with a storage emergency.
- Get the newest data on all of the codes obtainable at any level of time. Only then will you be capable of use them effectively. If you have any issues about exactly where and how to use promo kartu kredit, you can contact us at our site. One option to get the correct information is by 'liking' or 'following' a retailer on a social networking site. The company will reward you by sending you all its newest promo codes. You would possibly even get special provides which are distributed solely on social networking sites.
It is also a good suggestion to have a network of likeminded individuals who you possibly can share codes with and get good ones in return. If you are a wise shopper it is possible for you to to find the suitable promo code for almost every part you want to purchase, enabling you to avoid wasting thousands of dollars a year. Needless to say you may get the codes you want completely without spending a dime as long as you are keen to put in some effort to locate them.