amortized-analysis


Why we do Amortized Analysis for Fibonacci Heap?


In Fibonacci heap for all operations analysis are Amortized in nature. Why cant we have normal analysis as in case of Binomial Heap.
In a binomial heap, each operation is guaranteed to run with a certain worst-case performance. An insertion will never take more than time O(log n), a merge will never take more than time O(log n + log m), etc. Therefore, when analyzing the efficiency of a binomial heap, it's common to use a more traditional algorithmic analysis.
Now, that said, there are several properties of binomial heaps that only become apparent when doing an amortized analysis. For example, what's the cost of doing n consecutive insertions into a binomial heap, assuming the heap is initially empty? You can show that, in this case, the amortized cost of an insertion is O(1), meaning that the total cost of doing n insertions is O(n). In that sense, using an amortized analysis on top of a traditional analysis reveals more insights about the data structure than might initially arise from a more conservative worst-case analysis.
In some sense, Fibonacci heaps are best analyzed in an amortized sense because even though the worst-case bounds on many of the operations really aren't that great (for example, a delete-min or decrease-key can take time Θ(n) in the worst case), across any series of operations the Fibonacci heap has excellent amortized performance. Even though an individual delete-min might take Θ(n) time, it's never possible for a series of m delete-mins to take more than Θ(m log n) time.
In another sense, though, Fibonacci heaps were specifically designed to be efficient in an amortized sense rather than a worst-case sense. They were initially invented to speed up Dijkstra's and Prim's algorithms, where all that mattered were the total cost of doing m decrease-keys and n deletes on an n-node heap, and since that was the design goal, the designers made no attempt to make the Fibonacci heap efficient in the worst case.

Related Links

Amortized Analysis Example like dynamic array form
Can we use amortized analysis for best case analysis?
Why we do Amortized Analysis for Fibonacci Heap?
How is O(n)/n=1 in aggregate method of amortized analysis
is the amortized cost for increment and decrement binary counter the same?
Amortized Analysis: Find the Rate of Travel

Categories

HOME
maven
wso2-am
osgi
webpack
minimum-spanning-tree
lodash
bookshelf.js
google-docs
malloc
microservices
electronics
fsm
multiple-records
append
webrequest
esper
dax
nstableview
php-7.1
timeout
circuit
worldwind
opentracing
windows-7-x64
jsdoc
serilog
arabic
extjs5
devops
php-openssl
rundeck
xpages-ssjs
chromebook
info.plist
greendao
saas
jspm
srcset
junit5
google-qpx-express-api
stringtemplate
commit
overlap
suricata
dosbox
disassembling
mixture-model
user-controls
sas-visual-analytics
ensembles
mapzen
gulp-sourcemaps
glew
nomethoderror
bootstrap-dialog
sencha-touch-2.3
qcombobox
executenonquery
jsch
chain-builder
lift-json
qtwebview
iso8601
crosswalk-runtime
yt-project
parallel-data-warehouse
libpng
radtreelist
log4c
mongocsharpdriver
disque
nessus
rhino-servicebus
itextpdf
natvis
prerequisites
marching-cubes
collapse
atk4
muse
ios9.1
npapi
block-device
clicktag
camanjs
angularjs-ng-click
cctv
internet-connection
html-helper
htmlcleaner
prettify
ruby-datamapper
qt-faststart
jelly
wsdl-2.0
referrer
unc
jspinclude
libc++
qt-jambi
calling-convention
android-sdk-2.1
radcombobox
google-friend-connect
mozilla-prism
gin
fixed-width
compiler-specific
boost-smart-ptr
ajax-forms

Resources

Mobile Apps Dev
Database Users
javascript
java
csharp
php
android
MS Developer
developer works
python
ios
c
html
jquery
RDBMS discuss
Cloud Virtualization
Database Dev&Adm
javascript
java
csharp
php
python
android
jquery
ruby
ios
html
Mobile App
Mobile App
Mobile App