|
|
| (One intermediate revision by one other user not shown) |
| Line 1: |
Line 1: |
| In [[computer science]], a '''Fibonacci heap''' is a [[Heap (data structure)|heap data structure]] consisting of a collection of [[Tree (data structure)|tree]]s. It has a better [[amortized analysis|amortized]] running time than a [[binomial heap]]. Fibonacci heaps were developed by [[Michael Fredman|Michael L. Fredman]] and [[Robert Tarjan|Robert E. Tarjan]] in 1984 and first published in a scientific journal in 1987. The name of Fibonacci heap comes from [[Fibonacci number]]s which are used in the running time analysis.
| | Whether youre striving to lose 30 lbs or those last 5 lbs your diet will greatly influence your success. No matter how many crunches you do, laps around the track field like Rocky or time invested on the elliptical whilst checking out the girl on the stair master. It might all be for nothing if a diet is not inside check. Dieting will be difficult and depressing, but in the event you plan it out plus consistently create changes youll find it may be fun and convenient. These steps will assist you to design your diet to help you in the weight loss goals.<br><br>There is the [http://safedietplans.com/bmr-calculator bmr calculator] or Weight reduction calculator. BMR or Basal Metabolic Rate is the quantity of calories which you shred while at rest or without doing anything such as sitting idly in a chair or sleeping on a bed. But BMR Calculators will likely not simply calculate a idle methods and adds up your active methods throughout the day. Additionally, they will include in summing up the gender, age plus height of a person. The reason for this is considering those whom are elder more probably have lower metabolism than those which are young. This is also true for those which are taller plus have more muscle.<br><br>Drinking water additionally increases your basal metabolic rate. Your body has to procedure the water, plus inside doing this burns more calories. Studies equally show that drinking cold water burns more calories considering the body first has to bring the water about the internal temperature.<br><br>Are we starving yourself whilst striving to get rid of weight? You will be inside starvation mode. What is starvation mode? It is when the brain thinks you may be starving plus goes into protection mode. Your mind doesn't know you're simply striving to get rid of body fat. It thinks you are starving it because it's not getting enough food to help all of your body's functions. It's wanting the vitamins, minerals, plus phytonutrients it's lacking while in starvation mode. Wanting more so that the body plus mind functions optimally, it holds onto what it does have for security sake. It's holding onto your body fat. Whenever your brain offers the body this signal, you stop losing weight that is called a 'fat plateau." Your body nonetheless requires nutrients even if it happens to be overloaded with fat.<br><br>People constantly ask how many calories should they be consuming in a day to keep there fat, youll only have to do a little math. The initially step is calculating a bmr which this really is the amount of power your body takes inside and needs to function correctly. We use regarding 60% of the calories you consume everyday for the usual bodily functions including just by being alive plus breathing the others that influence a BMR are height, fat, age and sex.<br><br>The true secret to weight reduction is a extremely simple 1, although it can be a challenge. Just a few small changes which you make inside your every-day lifestyle can enable we lose the additional pounds without resorting to the cost (both financial and physical) of fad diets.<br><br>Nutritionists utilize the initial two formulas as a guideline to compute basic calorie requirements. They never compute additional calories used in exercise. The last one computes the calories different weight need based on activity level. |
| | |
| Find-minimum is ''O''(1) amortized time.<ref name="CLRS">[[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 20: Fibonacci Heaps, pp.476–497. Third edition p518.</ref> Operations insert, decrease key, and merge (union) work in constant amortized time.<ref name="Fredman And Tarjan"/> Operations delete and delete minimum work in [[Big O notation|''O'']](log ''n'') amortized time.<ref name="Fredman And Tarjan"/> This means that starting from an empty data structure, any sequence of ''a'' operations from the first group and ''b'' operations from the second group would take ''O''(''a'' + ''b'' log ''n'') time. In a [[binomial heap]] such a sequence of operations would take ''O''((''a'' + ''b'') log (''n'')) time. A Fibonacci heap is thus better than a binomial heap when ''b'' is [[asymptotic analysis|asymptotically]] smaller than ''a''.
| |
| | |
| Using Fibonacci heaps for [[priority queue]]s improves the asymptotic running time of important algorithms, such as [[Dijkstra's algorithm]] for computing the [[shortest path]] between two nodes in a graph.
| |
| | |
| == Structure ==
| |
| [[Image:Fibonacci heap.png|thumbnail|250px|Figure 1. Example of a Fibonacci heap. It has three trees of degrees 0, 1 and 3. Three vertices are marked (shown in blue). Therefore the potential of the heap is 9 (3 trees + 2 * marked-vertices).]]
| |
| A Fibonacci heap is a collection of [[tree data structure|tree]]s satisfying the [[minimum-heap property]], that is, the key of a child is always greater than or equal to the key of the parent. This implies that the minimum key is always at the root of one of the trees. Compared with binomial heaps, the structure of a Fibonacci heap is more flexible. The trees do not have a prescribed shape and in the extreme case the heap can have every element in a separate tree. This flexibility allows some operations to be executed in a "lazy" manner, postponing the work for later operations. For example merging heaps is done simply by concatenating the two lists of trees, and operation ''decrease key'' sometimes cuts a node from its parent and forms a new tree.
| |
| | |
| However at some point some order needs to be introduced to the heap to achieve the desired running time. In particular, degrees of nodes (here degree means the number of children) are kept quite low: every node has degree at most ''O''(log ''n'') and the size of a subtree rooted in a node of degree ''k'' is at least ''F<sub>k</sub>''<sub> + 2</sub>, where ''F<sub>k</sub>'' is the ''k''th [[Fibonacci number]]. This is achieved by the rule that we can cut at most one child of each non-root node. When a second child is cut, the node itself needs to be cut from its parent and becomes the root of a new tree (see Proof of degree bounds, below). The number of trees is decreased in the operation ''delete minimum'', where trees are linked together.
| |
| | |
| As a result of a relaxed structure, some operations can take a long time while others are done very quickly. For the [[amortized analysis|amortized running time]] analysis we use the [[potential method]], in that we pretend that very fast operations take a little bit longer than they actually do. This additional time is then later combined and subtracted from the actual running time of slow operations. The amount of time saved for later use is measured at any given moment by a potential function. The potential of a Fibonacci heap is given by
| |
| | |
| :Potential = ''t'' + 2''m''
| |
| | |
| where ''t'' is the number of trees in the Fibonacci heap, and ''m'' is the number of marked nodes. A node is marked if at least one of its children was cut since this node was made a child of another node (all roots are unmarked).
| |
| The amortized time for an operation is given by the sum of the actual time and ''c'' times the difference in potential, where ''c'' is a constant (chosen to match the constant factors in the ''O'' notation for the actual time).
| |
| | |
| Thus, the root of each tree in a heap has one unit of time stored. This unit of time can be used later to link this tree with another tree at amortized time 0. Also, each marked node has two units of time stored. One can be used to cut the node from its parent. If this happens, the node becomes a root and the second unit of time will remain stored in it as in any other root.
| |
| | |
| == Implementation of operations ==
| |
| To allow fast deletion and concatenation, the roots of all trees are linked using a circular, [[doubly linked list]]. The children of each node are also linked using such a list. For each node, we maintain its number of children and whether the node is marked. Moreover we maintain a pointer to the root containing the minimum key.
| |
| | |
| Operation '''find minimum''' is now trivial because we keep the pointer to the node containing it. It does not change the potential of the heap, therefore both actual and amortized cost is constant. As mentioned above, '''merge''' is implemented simply by concatenating the lists of tree roots of the two heaps. This can be done in constant time and the potential does not change, leading again to constant amortized time.
| |
| | |
| Operation '''insert''' works by creating a new heap with one element and doing merge. This takes constant time, and the potential increases by one, because the number of trees increases. The amortized cost is thus still constant.
| |
| | |
| [[Image:Fibonacci heap extractmin1.png|170px|thumb|right|Fibonacci heap from Figure 1 after first phase of extract minimum. Node with key 1 (the minimum) was deleted and its children were added as separate trees.]]
| |
| Operation '''extract minimum''' (same as ''delete minimum'') operates in three phases. First we take the root containing the minimum element and remove it. Its children will become roots of new trees. If the number of children was ''d'', it takes time ''O''(''d'') to process all new roots and the potential increases by ''d''−1. Therefore the amortized running time of this phase is ''O''(''d'') = ''O''(log ''n'').
| |
| | |
| [[Image:Fibonacci heap extractmin2.png|130px|thumb|left|Fibonacci heap from Figure 1 after extract minimum is completed. First, nodes 3 and 6 are linked together. Then the result is linked with tree rooted at node 2. Finally, the new minimum is found.]]
| |
| However to complete the extract minimum operation, we need to update the pointer to the root with minimum key. Unfortunately there may be up to ''n'' roots we need to check. In the second phase we therefore decrease the number of roots by successively linking together roots of the same degree. When two roots ''u'' and ''v'' have the same degree, we make one of them a child of the other so that the one with the smaller key remains the root. Its degree will increase by one. This is repeated until every root has a different degree. To find trees of the same degree efficiently we use an array of length ''O''(log ''n'') in which we keep a pointer to one root of each degree. When a second root is found of the same degree, the two are linked and the array is updated. The actual running time is ''O''(log ''n'' + ''m'') where ''m'' is the number of roots at the beginning of the second phase. At the end we will have at most ''O''(log ''n'') roots (because each has a different degree). Therefore the difference in the potential function from before this phase to after it is: ''O''(log ''n'') − ''m'', and the amortized running time is then at most ''O''(log ''n'' + ''m'') + ''c''(''O''(log ''n'') − ''m''). With a sufficiently large choice of ''c'', this simplifies to ''O''(log ''n'').
| |
| | |
| In the third phase we check each of the remaining roots and find the minimum. This takes ''O''(log ''n'') time and the potential does not change. The overall amortized running time of extract minimum is therefore ''O''(log ''n'').
| |
| | |
| [[Image:Fibonacci heap-decreasekey.png|250px|thumb|right|Fibonacci heap from Figure 1 after decreasing key of node 9 to 0. This node as well as its two marked ancestors are cut from the tree rooted at 1 and placed as new roots.]]
| |
| Operation '''decrease key''' will take the node, decrease the key and if the heap property becomes violated (the new key is smaller than the key of the parent), the node is cut from its parent. If the parent is not a root, it is marked. If it has been marked already, it is cut as well and its parent is marked. We continue upwards until we reach either the root or an unmarked node. In the process we create some number, say ''k'', of new trees. Each of these new trees except possibly the first one was marked originally but as a root it will become unmarked. One node can become marked. Therefore the number of marked nodes changes by −(''k'' − 1) + 1 = − ''k'' + 2. Combining these 2 changes, the potential changes by 2(−''k'' + 2) + ''k'' = −''k'' + 4. The actual time to perform the cutting was ''O''(''k''), therefore (again with a sufficiently large choice of ''c'') the amortized running time is constant.
| |
| | |
| Finally, operation '''delete''' can be implemented simply by decreasing the key of the element to be deleted to minus infinity, thus turning it into the minimum of the whole heap. Then we call extract minimum to remove it. The amortized running time of this operation is ''O''(log ''n'').
| |
| | |
| ==Proof of degree bounds==
| |
| The amortized performance of a Fibonacci heap depends on the degree (number of children) of any tree root being ''O''(log ''n''), where ''n'' is the size of the heap. Here we show that the size of the (sub)tree rooted at any node ''x'' of degree ''d'' in the heap must have size at least ''F<sub>d</sub>''<sub>+2</sub>, where ''F<sub>k</sub>'' is the ''k''th [[Fibonacci number]]. The degree bound follows from this and the fact (easily proved by induction) that <math>F_{d+2} \ge \varphi^d</math> for all integers <math>d\ge 0</math>, where <math>\varphi = (1+\sqrt 5)/2 \doteq 1.618</math>. (We then have <math>n \ge F_{d+2} \ge \varphi^d</math>, and taking the log to base <math>\varphi</math> of both sides gives <math>d\le \log_{\varphi} n</math> as required.)
| |
| | |
| Consider any node ''x'' somewhere in the heap (''x'' need not be the root of one of the main trees). Define '''size'''(''x'') to be the size of the tree rooted at ''x'' (the number of descendants of ''x'', including ''x'' itself). We prove by induction on the height of ''x'' (the length of a longest simple path from ''x'' to a descendant leaf), that '''size'''(''x'') ≥ ''F<sub>d</sub>''<sub>+2</sub>, where ''d'' is the degree of ''x''.
| |
| | |
| '''Base case:''' If ''x'' has height 0, then ''d'' = 0, and '''size'''(''x'') = 1 = ''F''<sub>2</sub>.
| |
| | |
| '''Inductive case:''' Suppose ''x'' has positive height and degree ''d''>0. Let ''y''<sub>1</sub>, ''y''<sub>2</sub>, ..., ''y<sub>d</sub>'' be the children of ''x'', indexed in order of the times they were most recently made children of ''x'' (''y''<sub>1</sub> being the earliest and ''y<sub>d</sub>'' the latest), and let ''c''<sub>1</sub>, ''c''<sub>2</sub>, ..., ''c<sub>d</sub>'' be their respective degrees. We '''claim''' that ''c<sub>i</sub>'' ≥ ''i''-2 for each ''i'' with 2≤''i''≤''d'': Just before ''y<sub>i</sub>'' was made a child of ''x'', ''y''<sub>1</sub>,...,''y<sub>i</sub>''<sub>−1</sub> were already children of ''x'', and so ''x'' had degree at least ''i''−1 at that time. Since trees are combined only when the degrees of their roots are equal, it must have been that ''y<sub>i</sub>'' also had degree at least ''i''-1 at the time it became a child of ''x''. From that time to the present, ''y<sub>i</sub>'' can only have lost at most one child (as guaranteed by the marking process), and so its current degree ''c<sub>i</sub>'' is at least ''i''−2. This proves the '''claim'''.
| |
| | |
| Since the heights of all the ''y<sub>i</sub>'' are strictly less than that of ''x'', we can apply the inductive hypothesis to them to get '''size'''(''y<sub>i</sub>'') ≥ ''F<sub>c<sub>i</sub></sub>''<sub>+2</sub> ≥ ''F''<sub>(''i''−2)+2</sub> = ''F<sub>i</sub>''. The nodes ''x'' and ''y''<sub>1</sub> each contribute at least 1 to '''size'''(''x''), and so we have
| |
| | |
| <math>\textbf{size}(x) \ge 2 + \sum_{i=2}^d \textbf{size}(y_i) \ge 2 + \sum_{i=2}^d F_i = 1 + \sum_{i=0}^d F_i.</math>
| |
| | |
| A routine induction proves that <math>1 + \sum_{i=0}^d F_i = F_{d+2}</math> for any <math>d\ge 0</math>, which gives the desired lower bound on '''size'''(''x'').
| |
| | |
| ==Worst case==
| |
| Although the total running time of a sequence of operations starting with an empty structure is bounded by the bounds given above, some (very few) operations in the sequence can take very long to complete (in particular delete and delete minimum have linear running time in the worst case). For this reason Fibonacci heaps and other amortized data structures may not be appropriate for [[real-time computing|real-time systems]]. It is possible to create a data structure which has the same worst case performance as the Fibonacci heap has amortized performance.<ref name="bare_url">{{Citation |id = [[CiteSeerX]]: {{url|1=citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.43.8133|2=10.1.1.43.8133}} |title=Worst-Case Efficient Priority Queues |year=1996 |author=Gerth Stølting Brodal |journal=Proc. 7th ACM-SIAM Symposium on Discrete Algorithms |publisher = [[Society for Industrial and Applied Mathematics]]|pages=52–58 |doi=10.1145/313852.313883 |isbn=0-89871-366-8}}</ref> However the resulting structure (a [[Brodal queue]]) is, in the words of the creator, "quite complicated" and "[not] applicable in practice."
| |
| | |
| ==Summary of running times==
| |
| {{Contradict-other|Heap (data structure)|there|Contradiction of running times|date=October 2013}}
| |
| {{main|Heap (data structure)#Comparison_of_theoretic_bounds_for_variants}}
| |
| | |
| {| class="wikitable"
| |
| |-
| |
| ! ''Common Operations''
| |
| ! ''Effect''
| |
| ! Unsorted [[Linked List]]
| |
| ! Sorted [[Linked List]]
| |
| ! [[Self-balancing binary search tree]]
| |
| ! [[Binary heap]]
| |
| ! [[Binomial heap]]
| |
| ! Fibonacci heap
| |
| ! [[Brodal queue]]<ref name="bare_url" />
| |
| ! [[Pairing heap]]
| |
| |-
| |
| | insert(data,key)
| |
| | Adds ''data'' to the queue, tagged with ''key''
| |
| | O(1)
| |
| | O(n)
| |
| | O(log n)
| |
| | O(log n)
| |
| | O(log n)
| |
| | O(1)
| |
| | O(1)
| |
| | O(1)<ref name="Fredman And Tarjan">{{cite journal|first1=Michael Lawrence|last1=Fredman|authorlink1=Michael Fredman|first2=Robert E.|last2=Tarjan|authorlink2=Robert Tarjan |title=Fibonacci heaps and their uses in improved network optimization algorithms| url = http://www.cl.cam.ac.uk/~sos22/supervise/dsaa/fib_heaps.pdf | format = PDF |journal=[[Journal of the Association for Computing Machinery]]|volume=34|year=1987|pages=596–615|ref=harv|doi=10.1145/28869.28874|issue=3}}</ref>
| |
| |-
| |
| | findMin() -> key,data
| |
| | Returns ''key,data'' corresponding to min-value ''key''
| |
| | O(n)
| |
| | O(1)
| |
| | O(log n) or O(1) (**)
| |
| | O(1)
| |
| | O(log n)<ref name="CLRS_generalized">{{Introduction to Algorithms|edition=1|chapter=}}</ref> or O(1) (**)
| |
| | O(1)<ref name="CLRS"/>
| |
| | O(1)
| |
| | O(1)<ref name="Fredman And Tarjan"/>
| |
| |-
| |
| | deleteMin()
| |
| | Deletes ''data'' corresponding to min-value ''key''
| |
| | O(n)
| |
| | O(1)
| |
| | O(log n)
| |
| | O(log n)
| |
| | O(log n)
| |
| | O(log n)*
| |
| | O(log n)
| |
| | O(log n)*<ref name="Fredman And Tarjan"/>
| |
| |-
| |
| | delete(node)
| |
| | Deletes ''data'' corresponding to given ''key'', given a pointer to the node being deleted
| |
| | O(1)
| |
| | O(1)
| |
| | O(log n)
| |
| | O(log n)
| |
| | O(log n)
| |
| | O(log n)*
| |
| | O(log n)
| |
| | O(log n)*<ref name="Fredman And Tarjan"/>
| |
| |-
| |
| | decreaseKey(node)
| |
| | Decreases the ''key'' of a node, given a pointer to the node being modified
| |
| | O(1)
| |
| | O(n)
| |
| | O(log n)
| |
| | O(log n)
| |
| | O(log n)
| |
| | O(1)*
| |
| | O(1)
| |
| | Unknown but bounded: <math>\Omega(\log\log n), {O(2^{2\sqrt{\log\log n}})}</math>*<ref name="Fredman And Tarjan"/><ref>{{cite journal|last=Pettie|first=Seth|title=Towards a Final Analysis of Pairing Heaps|journal=Max Planck Institut für Informatik|year=2005|url=http://web.eecs.umich.edu/~pettie/papers/focs05.pdf}}</ref>
| |
| |-
| |
| | merge(heap1,heap2) -> heap3
| |
| | Merges two heaps into a third
| |
| | O(1)
| |
| | O(m + n)
| |
| | O(m log(n+m))
| |
| | O(m log(n+m))
| |
| | O(log (m+n))
| |
| | O(1)*
| |
| | O(1)
| |
| | O(1)<ref name="Fredman And Tarjan"/>
| |
| |}
| |
| | |
| (*)Amortized time<br />
| |
| (**)With trivial modification to store an additional pointer to the minimum element
| |
| | |
| == References ==
| |
| {{reflist}}
| |
| | |
| == External links ==
| |
| * [http://www.cs.yorku.ca/~aaw/Jason/FibonacciHeapAnimation.html Java applet simulation of a Fibonacci heap]
| |
| * [http://www.mathworks.com/matlabcentral/fileexchange/30072-fibonacci-heap MATLAB implementation of Fibonacci heap]
| |
| * [http://www.labri.fr/perso/pelegrin/code/#fibonacci De-recursived and memory efficient C implementation of Fibonacci heap] (free/libre software, [http://www.cecill.info/licences/Licence_CeCILL-B_V1-en.html CeCILL-B license])
| |
| * [http://ideone.com/9jYnv C++ template Fibonacci heap, with demonstration]
| |
| * [http://github.com/evansenter/f_heap Ruby implementation of the Fibonacci heap (with tests)]
| |
| * [http://www.cs.princeton.edu/~wayne/cs423/fibonacci/FibonacciHeapAlgorithm.html Pseudocode of the Fibonacci heap algorithm]
| |
| * [http://stackoverflow.com/q/504823/194609 Efficient C++ Fibonacci heap]
| |
| * [http://stackoverflow.com/q/6273833/194609 Various Java Implementations for Fibonacci heap]
| |
| | |
| {{Data structures}}
| |
| | |
| {{DEFAULTSORT:Fibonacci Heap}}
| |
| [[Category:Fibonacci numbers]]
| |
| [[Category:Heaps (data structures)]]
| |
Whether youre striving to lose 30 lbs or those last 5 lbs your diet will greatly influence your success. No matter how many crunches you do, laps around the track field like Rocky or time invested on the elliptical whilst checking out the girl on the stair master. It might all be for nothing if a diet is not inside check. Dieting will be difficult and depressing, but in the event you plan it out plus consistently create changes youll find it may be fun and convenient. These steps will assist you to design your diet to help you in the weight loss goals.
There is the bmr calculator or Weight reduction calculator. BMR or Basal Metabolic Rate is the quantity of calories which you shred while at rest or without doing anything such as sitting idly in a chair or sleeping on a bed. But BMR Calculators will likely not simply calculate a idle methods and adds up your active methods throughout the day. Additionally, they will include in summing up the gender, age plus height of a person. The reason for this is considering those whom are elder more probably have lower metabolism than those which are young. This is also true for those which are taller plus have more muscle.
Drinking water additionally increases your basal metabolic rate. Your body has to procedure the water, plus inside doing this burns more calories. Studies equally show that drinking cold water burns more calories considering the body first has to bring the water about the internal temperature.
Are we starving yourself whilst striving to get rid of weight? You will be inside starvation mode. What is starvation mode? It is when the brain thinks you may be starving plus goes into protection mode. Your mind doesn't know you're simply striving to get rid of body fat. It thinks you are starving it because it's not getting enough food to help all of your body's functions. It's wanting the vitamins, minerals, plus phytonutrients it's lacking while in starvation mode. Wanting more so that the body plus mind functions optimally, it holds onto what it does have for security sake. It's holding onto your body fat. Whenever your brain offers the body this signal, you stop losing weight that is called a 'fat plateau." Your body nonetheless requires nutrients even if it happens to be overloaded with fat.
People constantly ask how many calories should they be consuming in a day to keep there fat, youll only have to do a little math. The initially step is calculating a bmr which this really is the amount of power your body takes inside and needs to function correctly. We use regarding 60% of the calories you consume everyday for the usual bodily functions including just by being alive plus breathing the others that influence a BMR are height, fat, age and sex.
The true secret to weight reduction is a extremely simple 1, although it can be a challenge. Just a few small changes which you make inside your every-day lifestyle can enable we lose the additional pounds without resorting to the cost (both financial and physical) of fad diets.
Nutritionists utilize the initial two formulas as a guideline to compute basic calorie requirements. They never compute additional calories used in exercise. The last one computes the calories different weight need based on activity level.