फाइबोनैचि हीप

कंप्यूटर विज्ञान में, फाइबोनैचि हीप प्राथमिकता कतार संचालन के लिए एक डेटा संरचना है, जिसमें हीप (डेटा संरचना)|हीप-ऑर्डर किए गए पेड़ों का संग्रह शामिल होता है। इसमें बाइनरी ढेर  और  द्विपद ढेर  सहित कई अन्य प्राथमिकता कतार डेटा संरचनाओं की तुलना में बेहतर परिशोधित विश्लेषण रनिंग टाइम है। माइकल फ्रेडमैन|माइकल एल. फ्रेडमैन और रॉबर्ट टार्जन|रॉबर्ट ई. टार्जन ने 1984 में फाइबोनैचि ढेर विकसित किया और उन्हें 1987 में एक वैज्ञानिक पत्रिका में प्रकाशित किया। फाइबोनैचि ढेर का नाम फाइबोनैचि संख्याओं के नाम पर रखा गया है, जिनका उपयोग उनके चलने के समय के विश्लेषण में किया जाता है।

फाइबोनैचि ढेर के लिए, खोज-न्यूनतम ऑपरेशन में स्थिर ( बिग ओ अंकन (1)) परिशोधित समय लगता है। सम्मिलित करना और घटाना कुंजी संचालन भी निरंतर परिशोधन समय में काम करते हैं। किसी तत्व को हटाना (अक्सर न्यूनतम तत्व को हटाने के विशेष मामले में उपयोग किया जाता है) ओ (लॉग एन) परिशोधन समय में काम करता है, जहां एन ढेर का आकार है। इसका मतलब यह है कि एक खाली डेटा संरचना से शुरू करके, सम्मिलित करने और कुंजी संचालन को कम करने और बी डिलीट संचालन के किसी भी अनुक्रम में ओ (ए + बी लॉग एन) सबसे खराब स्थिति का समय लगेगा, जहां एन अधिकतम ढेर आकार है। एक द्विआधारी या द्विपद ढेर में, संचालन के ऐसे अनुक्रम में O((a + b) log n) समय लगेगा। इस प्रकार एक फाइबोनैचि ढेर बाइनरी या द्विपद ढेर से बेहतर होता है जब बी एक गैर-स्थिर कारक से छोटा होता है। दो फाइबोनैचि ढेरों को निरंतर परिशोधन समय में मर्ज करना, एक द्विपद ढेर के लघुगणकीय विलय समय में सुधार करना और बाइनरी ढेरों में सुधार करना भी संभव है जो मर्ज को कुशलता से संभाल नहीं सकते हैं।

प्राथमिकता कतारों के लिए फाइबोनैचि हीप्स का उपयोग करने से महत्वपूर्ण एल्गोरिदम के एसिम्प्टोटिक रनिंग समय में सुधार होता है, जैसे कि एक ग्राफ में दो नोड्स के बीच सबसे छोटे पथ की गणना करने के लिए डिज्क्स्ट्रा का एल्गोरिदम, अन्य धीमी प्राथमिकता कतार डेटा संरचनाओं का उपयोग करने वाले समान एल्गोरिदम की तुलना में।

संरचना
फाइबोनैचि हीप ट्री डेटा संरचनाओं का एक संग्रह है जो न्यूनतम-हीप संपत्ति को संतुष्ट करता है, अर्थात, बच्चे की कुंजी हमेशा माता-पिता की कुंजी से अधिक या उसके बराबर होती है। इसका तात्पर्य यह है कि न्यूनतम कुंजी हमेशा किसी एक पेड़ की जड़ पर होती है। द्विपद ढेर की तुलना में, फाइबोनैचि ढेर की संरचना अधिक लचीली होती है। पेड़ों का कोई निर्धारित आकार नहीं होता है और चरम स्थिति में ढेर में प्रत्येक तत्व एक अलग पेड़ में हो सकता है। यह लचीलापन कुछ कार्यों को आलसी मूल्यांकन तरीके से निष्पादित करने की अनुमति देता है, जिससे काम को बाद के संचालन के लिए स्थगित कर दिया जाता है। उदाहरण के लिए, ढेरों का विलय केवल पेड़ों की दो सूचियों को जोड़कर किया जाता है, और ऑपरेशन कमी कुंजी कभी-कभी अपने मूल से एक नोड को काट देती है और एक नया पेड़ बनाती है।

हालाँकि, कुछ बिंदु पर वांछित रनिंग समय प्राप्त करने के लिए ढेर में ऑर्डर पेश करने की आवश्यकता होती है। विशेष रूप से, नोड्स की डिग्री (यहां डिग्री का मतलब सीधे बच्चों की संख्या है) को काफी कम रखा गया है: प्रत्येक नोड में अधिकतम लॉग एन पर डिग्री होती है और डिग्री के नोड में निहित उपट्री का आकार कम से कम एफ होता हैk+2, जहां एफkkth फाइबोनैचि संख्या है. यह इस नियम से प्राप्त होता है कि हम प्रत्येक गैर-रूट नोड के अधिकतम एक बच्चे को काट सकते हैं। जब दूसरे बच्चे को काटा जाता है, तो नोड को अपने माता-पिता से अलग होना पड़ता है और एक नए पेड़ की जड़ बन जाती है (डिग्री सीमा का प्रमाण नीचे देखें)। ऑपरेशन डिलीट मिनिमम में पेड़ों की संख्या कम हो जाती है, जहां पेड़ों को एक साथ जोड़ा जाता है।

एक आरामदायक संरचना के परिणामस्वरूप, कुछ ऑपरेशनों में लंबा समय लग सकता है जबकि अन्य बहुत जल्दी किए जाते हैं। परिशोधित विश्लेषण विश्लेषण के लिए, हम संभावित विधि का उपयोग करते हैं, इसमें हम दिखावा करते हैं कि बहुत तेज़ संचालन वास्तव में करने की तुलना में थोड़ा अधिक समय लेते हैं। इस अतिरिक्त समय को बाद में जोड़ दिया जाता है और धीमे संचालन के वास्तविक चलने के समय से घटा दिया जाता है। बाद में उपयोग के लिए बचाए गए समय की मात्रा को किसी भी क्षण संभावित फ़ंक्शन द्वारा मापा जाता है। फाइबोनैचि ढेर की क्षमता किसके द्वारा दी गई है?


 * संभाव्यता = t + 2m

जहां t फाइबोनैचि ढेर में पेड़ों की संख्या है, और m चिह्नित नोड्स की संख्या है। एक नोड को चिह्नित किया जाता है यदि उसके कम से कम एक बच्चे को काट दिया गया हो क्योंकि इस नोड को दूसरे नोड का बच्चा बना दिया गया था (सभी जड़ें अचिह्नित हैं)। किसी ऑपरेशन के लिए परिशोधन समय वास्तविक समय के योग और क्षमता में अंतर के सी गुना द्वारा दिया जाता है, जहां सी एक स्थिरांक है (वास्तविक समय के लिए ओ नोटेशन में स्थिर कारकों से मेल खाने के लिए चुना गया है)।

इस प्रकार, ढेर में प्रत्येक पेड़ की जड़ में समय की एक इकाई संग्रहीत होती है। समय की इस इकाई का उपयोग बाद में परिशोधन समय 0 पर इस पेड़ को दूसरे पेड़ से जोड़ने के लिए किया जा सकता है। साथ ही, प्रत्येक चिह्नित नोड में समय की दो इकाइयाँ संग्रहीत होती हैं। एक का उपयोग नोड को उसके मूल से काटने के लिए किया जा सकता है। यदि ऐसा होता है, तो नोड एक रूट बन जाता है और समय की दूसरी इकाई किसी अन्य रूट की तरह इसमें संग्रहीत रहेगी।

संचालन का कार्यान्वयन
तेजी से विलोपन और संयोजन की अनुमति देने के लिए, सभी पेड़ों की जड़ों को एक गोलाकार दोगुनी लिंक्ड सूची का उपयोग करके जोड़ा जाता है। प्रत्येक नोड के बच्चे भी ऐसी सूची का उपयोग करके जुड़े हुए हैं। प्रत्येक नोड के लिए, हम उसके बच्चों की संख्या बनाए रखते हैं और क्या नोड चिह्नित है। इसके अलावा, हम न्यूनतम कुंजी वाले रूट पर एक पॉइंटर बनाए रखते हैं।

ऑपरेशन फाइंड मिनिमम अब तुच्छ हो गया है क्योंकि हम पॉइंटर को उस नोड पर रखते हैं जिसमें यह शामिल है। यह ढेर की क्षमता को नहीं बदलता है, इसलिए वास्तविक और परिशोधित लागत दोनों स्थिर हैं।

जैसा कि ऊपर उल्लेख किया गया है, मर्ज को केवल दो ढेरों के पेड़ की जड़ों की सूचियों को जोड़कर लागू किया जाता है। यह निरंतर समय में किया जा सकता है और क्षमता नहीं बदलती है, जिससे फिर से निरंतर परिशोधन समय हो जाता है।

ऑपरेशन इंसर्ट एक तत्व के साथ एक नया ढेर बनाकर और मर्ज करके काम करता है। इसमें निरंतर समय लगता है, और क्षमता एक से बढ़ जाती है, क्योंकि पेड़ों की संख्या बढ़ जाती है। इस प्रकार परिशोधन लागत अभी भी स्थिर है।

ऑपरेशन एक्सट्रेक्ट मिनिमम ('डिलीट मिनिमम' के समान) तीन चरणों में संचालित होता है। सबसे पहले हम न्यूनतम तत्व वाला मूल लेते हैं और उसे हटा देते हैं। इसके बच्चे नये वृक्षों की जड़ें बनेंगे। यदि बच्चों की संख्या d थी, तो सभी नई जड़ों को संसाधित करने में O(d) समय लगता है और क्षमता d−1 तक बढ़ जाती है। इसलिए, इस चरण का परिशोधन चलने का समय O(d) = O(log n) है।

हालाँकि, एक्सट्रेक्ट मिनिमम ऑपरेशन को पूरा करने के लिए, हमें पॉइंटर को न्यूनतम कुंजी के साथ रूट पर अपडेट करना होगा। दुर्भाग्य से एन तक जड़ें हो सकती हैं जिनकी हमें जांच करने की आवश्यकता है। इसलिए दूसरे चरण में हम समान डिग्री की जड़ों को क्रमिक रूप से एक साथ जोड़कर जड़ों की संख्या कम करते हैं। जब दो जड़ों u और v की डिग्री समान होती है, तो हम उनमें से एक को दूसरे की संतान बनाते हैं ताकि छोटी कुंजी वाला मूल बना रहे। इसकी डिग्री एक से बढ़ जाएगी. इसे तब तक दोहराया जाता है जब तक कि प्रत्येक जड़ की अलग-अलग डिग्री न हो जाए। समान डिग्री के पेड़ों को कुशलतापूर्वक खोजने के लिए हम ओ (लॉग एन) लंबाई की एक सरणी का उपयोग करते हैं जिसमें हम प्रत्येक डिग्री के एक मूल के लिए एक संकेतक रखते हैं। जब समान डिग्री का दूसरा रूट पाया जाता है, तो दोनों जुड़े होते हैं और एरे को अपडेट किया जाता है। वास्तविक चलने का समय O (लॉग n + m) है जहां m दूसरे चरण की शुरुआत में जड़ों की संख्या है। अंत में हमारे पास अधिकतम O(log n) मूल होंगे (क्योंकि प्रत्येक की एक अलग डिग्री होती है)। इसलिए, इस चरण के पहले से लेकर इसके बाद तक संभावित फ़ंक्शन में अंतर है: ओ(लॉग एन) - एम, और परिशोधित चलने का समय अधिकतम ओ है '(लॉग एन + एम) + सी(ओ(लॉग एन) - एम)। सी के पर्याप्त बड़े विकल्प के साथ, यह ओ(लॉग एन) तक सरल हो जाता है।

तीसरे चरण में हम प्रत्येक शेष मूल की जाँच करते हैं और न्यूनतम ज्ञात करते हैं। इसमें O(log n) समय लगता है और विभव नहीं बदलता है। इसलिए न्यूनतम निकालने का कुल परिशोधन समय O(लॉग एन) है।

ऑपरेशन 'कमी कुंजी' नोड लेगा, कुंजी को कम करेगा और यदि ढेर संपत्ति का उल्लंघन हो जाता है (नई कुंजी मूल की कुंजी से छोटी है), तो नोड को उसके मूल से काट दिया जाता है। यदि अभिभावक मूल नहीं है, तो इसे चिह्नित किया जाता है। यदि इसे पहले से ही चिह्नित किया गया है, तो इसे भी काट दिया जाता है और इसके मूल को चिह्नित किया जाता है। हम तब तक ऊपर की ओर बढ़ते रहते हैं जब तक हम मूल या अचिह्नित नोड तक नहीं पहुंच जाते। अब हम न्यूनतम सूचक को घटे हुए मान पर सेट करते हैं यदि यह नया न्यूनतम है। इस प्रक्रिया में हम नए पेड़ों की कुछ संख्या, मान लीजिए k, बनाते हैं। संभवतः पहले पेड़ को छोड़कर इनमें से प्रत्येक नए पेड़ को मूल रूप से चिह्नित किया गया था, लेकिन जड़ के रूप में यह अचिह्नित हो जाएगा। एक नोड चिह्नित किया जा सकता है. इसलिए, चिह्नित नोड्स की संख्या −(k − 1) −+ 1 − = − −k −2 से बदल जाती है। इन 2 परिवर्तनों को मिलाकर, संभावित 2(−k − 2) − −k − − −k − 4 − 4 से बदल जाती है। वास्तविक समय कटिंग करने के लिए ओ(के) था, इसलिए (फिर से सी के पर्याप्त बड़े विकल्प के साथ) परिशोधन चलने का समय स्थिर है।

अंत में, ऑपरेशन 'डिलीट' को हटाए जाने वाले तत्व की कुंजी को शून्य से अनंत तक कम करके कार्यान्वित किया जा सकता है, इस प्रकार इसे पूरे ढेर के न्यूनतम में बदल दिया जा सकता है। फिर हम इसे हटाने के लिए एक्सट्रैक्ट मिनिमम कहते हैं। इस ऑपरेशन का परिशोधन चलने का समय O(लॉग एन) है।

डिग्री सीमा का प्रमाण
फाइबोनैचि ढेर का परिशोधन प्रदर्शन किसी भी पेड़ की जड़ की डिग्री (बच्चों की संख्या) ओ (लॉग एन) पर निर्भर करता है, जहां एन ढेर का आकार है। यहां हम दिखाते हैं कि ढेर में डिग्री डी के किसी भी नोड x पर जड़े (उप) पेड़ का आकार कम से कम एफ होना चाहिएd+2, जहां एफkkth फाइबोनैचि संख्या है. डिग्री की बाध्यता इस और तथ्य (आसानी से प्रेरण द्वारा सिद्ध) से अनुसरण करती है $$F_{d+2} \ge \varphi^d$$ सभी पूर्णांकों के लिए $$d\ge 0$$, कहाँ $$\varphi = (1+\sqrt 5)/2 \doteq 1.618$$. (तब हमारे पास है $$n \ge F_{d+2} \ge \varphi^d$$, और लॉग को आधार पर ले जाना $$\varphi$$ दोनों पक्षों का देता है $$d\le \log_{\varphi} n$$ आवश्यकता अनुसार।)

ढेर में कहीं किसी भी नोड x पर विचार करें (x को मुख्य पेड़ों में से एक की जड़ होने की आवश्यकता नहीं है)। 'आकार'(x) को x पर जड़े पेड़ के आकार के रूप में परिभाषित करें (x के वंशजों की संख्या, जिसमें स्वयं x भी शामिल है)। हम x की ऊंचाई (x से वंशज पत्ती तक के सबसे लंबे सरल पथ की लंबाई) पर प्रेरण द्वारा साबित करते हैं कि 'आकार' (x) ≥ Fd+2, जहां d x की डिग्री है।

'बेस केस:' यदि x की ऊंचाई 0 है, तो d = 0, और 'आकार'(x) = 1 = F2.

आगमनात्मक मामला: मान लीजिए x की ऊंचाई सकारात्मक है और डिग्री d > 0 है। मान लीजिए y1, और2, ..., औरdx के बच्चे हों, उन्हें उस समय के क्रम में अनुक्रमित किया जाए जब वे हाल ही में x (y) के बच्चे बने थे1 सबसे पहले और वाई होने के नातेdनवीनतम), और चलो सी1, सी2, ..., सीdउनकी संबंधित डिग्री हो. हम 'दावा' करते हैं कि सीi≥ i-2 प्रत्येक i के लिए 2 ≤ i ≤ d के साथ: y से ठीक पहलेix, y का बच्चा बना दिया गया1,...,औरi−1 वे पहले से ही x के बच्चे थे, और इसलिए x के पास उस समय कम से कम i−1 की डिग्री थी। चूँकि वृक्षों का संयोजन तभी होता है जब उनकी जड़ों की डिग्री समान होती है, इसलिए ऐसा अवश्य हुआ होगाiजब वह x का बच्चा बना तो उसके पास कम से कम i-1 डिग्री भी थी। उस समय से लेकर आज तक, यiअधिकतम केवल एक बच्चा ही खोया जा सकता है (जैसा कि अंकन प्रक्रिया द्वारा गारंटी दी गई है), और इसलिए इसकी वर्तमान डिग्री सीiकम से कम i−2 है. इससे 'दावा' साबित होता है.

चूँकि सभी y की ऊँचाइयाँix की तुलना में बिल्कुल कम हैं, हम 'आकार'(y) प्राप्त करने के लिए उन पर आगमनात्मक परिकल्पना लागू कर सकते हैंi) ≥एफc i+2≥एफ(i−2)+2= एफi. नोड्स x और y1 प्रत्येक आकार(x) में कम से कम 1 योगदान देता है, और इसलिए हमारे पास है

$$\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.$$ एक नियमित प्रेरण यह साबित करता है $$1 + \sum_{i=0}^d F_i = F_{d+2}$$ किसी के लिए $$d\ge 0$$, जो आकार (x) पर वांछित निचली सीमा देता है।

सबसे ख़राब मामला
हालाँकि फाइबोनैचि ढेर बहुत कुशल दिखते हैं, उनमें निम्नलिखित दो कमियाँ हैं:
 * 1) जब इन्हें लागू करने की बात आती है तो ये जटिल हो जाते हैं।
 * 2) ढेर के सैद्धांतिक रूप से कम कुशल रूपों की तुलना में वे व्यवहार में उतने कुशल नहीं हैं। अपने सरलतम संस्करण में उन्हें प्रति नोड चार पॉइंटर्स के भंडारण और हेरफेर की आवश्यकता होती है, जबकि अन्य संरचनाओं में प्रति नोड केवल दो या तीन पॉइंटर्स की आवश्यकता होती है, जैसे कि बाइनरी हीप, बाइनोमियल हीप,  युग्मन ढेर, ब्रोडल कतार और रैंक पेयरिंग हीप।

यद्यपि एक खाली संरचना से शुरू होने वाले संचालन के अनुक्रम का कुल चलने का समय ऊपर दी गई सीमाओं से घिरा हुआ है, अनुक्रम में कुछ (बहुत कम) संचालन को पूरा होने में बहुत लंबा समय लग सकता है (विशेष रूप से हटाएं और हटाएं में न्यूनतम रैखिक चलने का समय होता है) सबसे ख़राब मामला)। इस कारण से फाइबोनैचि ढेर और अन्य परिशोधित डेटा संरचनाएं वास्तविक समय कंप्यूटिंग | वास्तविक समय प्रणालियों के लिए उपयुक्त नहीं हो सकती हैं। ऐसी डेटा संरचना बनाना संभव है जिसका प्रदर्शन उतना ही खराब हो जितना कि फाइबोनैचि हीप का परिशोधित प्रदर्शन। ऐसी ही एक संरचना, ब्रोडल कतार,, रचनाकार के शब्दों में, काफी जटिल है और व्यवहार में लागू नहीं होता है। 2012 में बनाया गया, सख्त फाइबोनैचि ढेर रेफरी> समान सबसे खराब स्थिति वाली एक सरल (ब्रोडल की तुलना में) संरचना है। सरल संरचना होने के बावजूद, प्रयोगों से पता चलता है कि व्यवहार में सख्त फाइबोनैचि ढेर अधिक जटिल ब्रोडल कतार की तुलना में धीमा प्रदर्शन करता है और बुनियादी फाइबोनैचि ढेर की तुलना में भी धीमा है। रेफरी> ड्रिस्कॉल एट अल के रन-रिलैक्स्ड ढेर। मर्ज को छोड़कर सभी फाइबोनैचि हीप संचालन के लिए सबसे खराब स्थिति में अच्छा प्रदर्शन दें।

व्यावहारिक विचार
फाइबोनैचि हीप्स को व्यवहार में धीमे होने के लिए जाना जाता है प्रति नोड बड़ी मेमोरी खपत और सभी परिचालनों पर उच्च स्थिर कारकों के कारण। हाल के प्रयोगात्मक परिणामों से पता चलता है कि फाइबोनैचि ढेर अपने अधिकांश बाद के डेरिवेटिव की तुलना में व्यवहार में अधिक कुशल हैं, जिनमें भूकंप ढेर, उल्लंघन ढेर, सख्त फाइबोनैचि ढेर, रैंक पेयरिंग ढेर शामिल हैं, लेकिन युग्मन ढेर या सरणी-आधारित ढेर की तुलना में कम कुशल हैं।

बाहरी संबंध

 * Java applet simulation of a Fibonacci heap
 * MATLAB implementation of Fibonacci heap
 * De-recursived and memory efficient C implementation of Fibonacci heap (free/libre software, CeCILL-B license)
 * Ruby implementation of the Fibonacci heap (with tests)
 * Pseudocode of the Fibonacci heap algorithm
 * Various Java Implementations for Fibonacci heap