This is a good article. Click here for more information.

बाइनरी सर्च ट्री: Difference between revisions

From Vigyanwiki
No edit summary
 
(33 intermediate revisions by 4 users not shown)
Line 4: Line 4:
}}
}}


[[File:Binary search tree.svg|right|upright=0.8|thumb|चित्र 1: आकार 9 और गहराई 3 का एक बाइनरी सर्च ट्री, जिसकी जड़ 8 है। पत्तियाँ नहीं खींची जाती हैं।]][[कंप्यूटर विज्ञान]] में एक बाइनरी सर्च ट्री (बीएसटी) जिसे क्रमांक या सॉर्टेड [[बाइनरी ट्री]] भी कहा जाता है एक [[ जड़ वाला पेड़ |जड़ वाला पेड़]] बाइनरी ट्री [[डेटा संरचना]] है जिसमें आंतरिक कुंजी बाएं उप पेंड़ की सभी कुंजियों से अधिक नहीं होती हैं तथा कम होती हैं इसके दाहिने उप पेंड़ की तुलना में बाइनरी सर्च ट्री पर संचालन की [[समय जटिलता]] सीधे पेड़ की ऊंचाई के समानुपाती होती है।
[[File:Binary search tree.svg|right|upright=0.8|thumb|चित्र 1: आकार 9 और गहराई 3 का एक बाइनरी सर्च ट्री, जिसकी जड़ 8 है। पत्तियाँ नहीं खींची जाती हैं।]]कम्प्यूटर [[कंप्यूटर विज्ञान|विज्ञान एक]] बाइनरी सर्च ट्री है  जिसे क्रम या चयनित [[बाइनरी ट्री|बाइनरी]] ट्री भी कहा जाता है एक [[रूटेड]] बाइनरी ट्री [[डेटा संरचना]] है जिसकी आंतरिक कुंजी बाएं सर्च ट्री की सभी कुंजियों से अधिक होती हैं और उससे कम होती हैं बाइनरी सर्च ट्री पर एक संचालन की [[समय जटिलता]] सीधे ट्री की ऊंचाई के समानुपाती होती है।


बाइनरी सर्च ट्री डेटा आइटम्स को तेजी से देखने जोड़ने और हटाने के लिए [[बाइनरी सर्च एल्गोरिथम]] की अनुमति देता है क्योंकि बीएसटी में प्रोप इस तरह रखे गए हैं कि प्रत्येक तुलना शेष पेड़ के आधे हिस्से को छोड़ देती है प्रदर्शन खोजना [[द्विआधारी लघुगणक]] के समानुपाती होता है। लेबल किए गए डेटा के कुशल भंडारण की समस्या के लिए 1960 के दशक में बीएसटी तैयार किए गए थे और इसका श्रेय [[कॉनवे बर्नर्स-ली]] और डेविडव्हीलर कंप्यूटर के वैज्ञानिक को दिया जाता है।
एक बाइनरी सर्च ट्री बाइनरी सर्च को डेटा [[आइटम्स|इकाई]] को जल्दी से देखने जोड़ने और हटाने की अनुमति देता है क्योंकि बीएसटी में नोड्स इस तरह रखे जाते हैं कि प्रत्येक तुलना शेष सर्च ट्री के आधे हिस्से को छोड़ देती है अवलोकन  प्रदर्शन [[बाइनरी]] [[द्विआधारी लघुगणक|लघुगणक]] के समानुपाती होता है बीएसटी को 1960 के दशक में लेबल किए गए डेटा के कुशल भंडारण की समस्या के लिए तैयार किया गया था और इसका श्रेय [[कॉनवे बर्नर्स-ली]] और डेविड व्हीलर को दिया जाता है।


बाइनरी सर्च ट्री का प्रदर्शन पेड़ में नोड्स के सम्मिलन के क्रम पर निर्भर करता है क्योंकि मनमाना सम्मिलन अर्धपतन का कारण बन सकता है बाइनरी सर्च ट्री के कई रूपों को सबसे खराब स्थिति के प्रदर्शन की गारंटी के साथ बनाया जा सकता है क्योंकि इसमें मूल संचालन में सम्मिलित हैं   सबसे खराब स्थिति जटिलता वाले बीएसटी एक अवर्गीकृत सरणी से बेहतर प्रदर्शन करते हैं जिनको [[रैखिक समय]] की आवश्यकता होती है।
सर्च ट्री का प्रदर्शन ट्री में नोड्स के सम्मिलन के क्रम पर निर्भर करता है क्योंकि मनमाना सम्मिलन अर्धपतन का कारण बन जाता है बाइनरी सर्च ट्री के कई रूपों को सबसे खराब स्थिति के प्रदर्शन की गारंटी के साथ बनाया जाता है क्योंकि इसमें मूल संचालन सम्मिलित हैं सबसे खराब स्थिति वाले बीएसटी एक अवर्गीकृत सारणी से बेहतर प्रदर्शन करते हैं जिनको [[रैखिक समय]] की आवश्यकता होती है।


बीएसटी के [[कम्प्यूटेशनल जटिलता सिद्धांत]] से पता चलता है कि अच्छा सबसे खराब और औसत स्थित, डालें, हटायें और खोजें भी सम्मिलित हैं। वे एक एकल लिंक की सूची सम्मिलन और विलोपन के साथ पेड़ की ऊंचाई की असीमित वृद्धि को संबोधित करने के लिए बीएसटी के स्व-संतुलन बाइनरी सर्च ट्री संतुलन रूपों को बाइनरी शुरूआत की सबसे खराब  जटिलता को बाध्य करने के लिए पेश किया जाता है। एवीएल पेड़ पहला स्व संतुलन बाइनरी सर्च ट्री था जिसका आविष्कार 1962 में [[Georgy Adelson-Velsky|एवीएल एड्स वेल्सकी]] और [[Evgenii Landis|ईव्जेनी लैन्डिस]] द्वारा किया गया था।
बीएसटी के [[जटिलता]] विश्लेषण से पता चलता है कि औसतन डालने हटाने और खोजने में नोड्स के लिए n लगते हैं कि इसमें औसत स्थित और खोजें भी सम्मिलित हैं वे एक एकल लिंक की सूची सम्मिलन और विलोपन के साथ सर्च ट्री की ऊंचाई की असीमित वृद्धि को संबोधित करने के लिए बीएसटी के स्व-संतुलन बाइनरी सर्च ट्री संतुलन के रूपों को बाइनरी में शुरूआत करने की जटिलता को बाध्य करने के लिए पेश करते हैं इसमें एवीएल ट्री पहला स्व संतुलन बाइनरी सर्च ट्री था जिसका आविष्कार 1962 में [[Georgy Adelson-Velsky|एवीएल एड्स वेल्सकी]] और [[Evgenii Landis|ईव्जेनी लैन्डिस]] द्वारा किया गया था।


बाइनरी सर्च ट्री का उपयोग अमूर्त डेटा प्रकारों जैसे सेट और [[प्राथमिकता कतार|प्राथमिकता पंक्ति]] को लागू करने के लिए किया जा सकता है और [[छँटाई एल्गोरिथ्म]] जैसे [[पेड़ की छँटाई]] में उपयोग किया जाता है।
बाइनरी सर्च ट्री का उपयोग अमूर्त डेटा जैसे सेट और [[प्राथमिकता कतार|प्राथमिकता पंक्ति]] को लागू करने के लिए किया जाता है और बाइनरी सर्च ट्री में इसका उपयोग किया जाता है।


== इतिहास ==
== इतिहास ==
बाइनरी सर्च ट्री एल्गोरिथम स्वतंत्र रूप से कई शोधकर्ताओं द्वारा खोजा गया था जिसमें पी.एफ. विंडले [[एंड्रयू डोनाल्ड बूथ]] [[एंड्रयू कॉलिन]] थॉमस एन. हिब्बार्ड तथा <ref name="computer_journal89">{{cite journal|journal=[[The Computer Journal]]|date=1 January 1989|doi=10.1093/comjnl/32.1.68|volume=32|issue=1|pages=68–69|first1=J.|last1=Culberson|first2=J. I.|last2=Munro|url=https://academic.oup.com/comjnl/article/32/1/68/341965?login=true|doi-access=free|title=लंबे समय तक अपडेट के तहत बाइनरी सर्च ट्री के व्यवहार की व्याख्या: एक मॉडल और सिमुलेशन}}</ref><ref>{{cite journal|journal=[[Algorithmica]]|publisher=[[Springer Publishing]], [[University of Waterloo]]|title= सटीक फिट डोमेन बाइनरी सर्च ट्री में मानक विलोपन एल्गोरिदम का विश्लेषण|date=28 July 1986|doi=10.1007/BF01840390|url=https://link.springer.com/article/10.1007%2FBF01840390|first1=J.|last1=Culberson|first2=J. I.|last2=Munro|volume=5 |issue=1–4 |page=297|s2cid=971813 }}</ref> एल्गोरिथ्म का श्रेय कॉनवे बर्नर्स-ली और [[डेविड व्हीलर (कंप्यूटर वैज्ञानिक)|डेविड व्हीलर कंप्यूटर वैज्ञानिक]] को दिया जाता है जिन्होंने 1960 में [[चुंबकीय टेप]] में [[लेबल किए गए डेटा]] को संग्रहीत करने के लिए इसका उपयोग किया था।<ref name="windley60">{{cite journal|journal=[[The Computer Journal]]|date=1 January 1960|doi=10.1093/comjnl/3.2.84|url=https://academic.oup.com/comjnl/article/3/2/84/504799|author=P. F. Windley|volume=3|issue=2|page=84|title= पेड़, वन और पुनर्व्यवस्था|doi-access=free}}</ref> सबसे शुरुआती और लोकप्रिय बाइनरी सर्च ट्री एल्गोरिथम हिब्बार्ड का है।<ref name="computer_journal89" />
बाइनरी सर्च ट्री प्रदर्शन स्वतंत्र रूप से कई शोधकर्ताओं द्वारा खोजा गया था जिसमें पी.एफ.विंडले [[एंड्रयू डोनाल्ड बूथ]] [[एंड्रयू कॉलिन]] थॉमस एन. हिब्बार्ड तथा <ref name="computer_journal89">{{cite journal|journal=[[The Computer Journal]]|date=1 January 1989|doi=10.1093/comjnl/32.1.68|volume=32|issue=1|pages=68–69|first1=J.|last1=Culberson|first2=J. I.|last2=Munro|url=https://academic.oup.com/comjnl/article/32/1/68/341965?login=true|doi-access=free|title=लंबे समय तक अपडेट के तहत बाइनरी सर्च ट्री के व्यवहार की व्याख्या: एक मॉडल और सिमुलेशन}}</ref><ref>{{cite journal|journal=[[Algorithmica]]|publisher=[[Springer Publishing]], [[University of Waterloo]]|title= सटीक फिट डोमेन बाइनरी सर्च ट्री में मानक विलोपन एल्गोरिदम का विश्लेषण|date=28 July 1986|doi=10.1007/BF01840390|url=https://link.springer.com/article/10.1007%2FBF01840390|first1=J.|last1=Culberson|first2=J. I.|last2=Munro|volume=5 |issue=1–4 |page=297|s2cid=971813 }}</ref> प्रदर्शन का श्रेय कॉनवे बर्नर्स-ली और [[डेविड व्हीलर (कंप्यूटर वैज्ञानिक)|डेविड व्हीलर कंप्यूटर वैज्ञानिक]] को दिया जाता है जिन्होंने 1960 में [[चुंबकीय टेप]] में [[लेबल किए गए डेटा|विवरण किए गए डेटा]] को संग्रहित करने के लिए किया गया था।<ref name="windley60">{{cite journal|journal=[[The Computer Journal]]|date=1 January 1960|doi=10.1093/comjnl/3.2.84|url=https://academic.oup.com/comjnl/article/3/2/84/504799|author=P. F. Windley|volume=3|issue=2|page=84|title= पेड़, वन और पुनर्व्यवस्था|doi-access=free}}</ref>  


बाइनरी सर्च ट्री की समय जटिलताएं पेड़ की ऊंचाई के साथ असीम रूप से बढ़ जाती हैं यदि नोड्स को एक मनमाने क्रम में डाला जाता है तो पेंड़ की ऊंचाई को सीमित करने के लिए [[स्व-संतुलन बाइनरी सर्च ट्री|स्व-संतुलन बाइनरी सर्च पेंड़]] पेश किए गए थे <ref name="Knuth98">{{cite book|title=कंप्यूटर प्रोग्रामिंग की कला|first=Donald|last=Knuth|author-link=Donald_Knuth|publisher=[[Addison-Wesley]]|year=1998|chapter=Section 6.2.3: Balanced Trees|pages=458–481|volume=3|edition=2|url=https://ia801604.us.archive.org/17/items/B-001-001-250/B-001-001-250.pdf |archive-url=https://ghostarchive.org/archive/20221009/https://ia801604.us.archive.org/17/items/B-001-001-250/B-001-001-250.pdf |archive-date=2022-10-09 |url-status=live|isbn=978-0201896855
बाइनरी सर्च ट्री की जटिलताएं असीम रूप से बढ़ रही हैं यदि नोड्स को एक मनमाने क्रम में डालते हैं तो बाइनरी सर्च ट्री की ऊंचाई को सीमित करने के लिए [[स्व-संतुलन बाइनरी सर्च ट्री|स्व-संतुलन]] पेश किए गए थे <ref name="Knuth98">{{cite book|title=कंप्यूटर प्रोग्रामिंग की कला|first=Donald|last=Knuth|author-link=Donald_Knuth|publisher=[[Addison-Wesley]]|year=1998|chapter=Section 6.2.3: Balanced Trees|pages=458–481|volume=3|edition=2|url=https://ia801604.us.archive.org/17/items/B-001-001-250/B-001-001-250.pdf |archive-url=https://ghostarchive.org/archive/20221009/https://ia801604.us.archive.org/17/items/B-001-001-250/B-001-001-250.pdf |archive-date=2022-10-09 |url-status=live|isbn=978-0201896855
}}</ref> पेड़ की ऊंचाई को सीमित करने के लिए विभिन्न ऊंचाई-संतुलित द्विआधारी खोज पेड़ पेश किए गए जैसे एवीएल पेड़ [[ट्रीप]] और लाल-काले पेड़ <ref>Paul E. Black, "red-black tree", in Dictionary of Algorithms and Data Structures [online], Paul E. Black, ed. 12 November 2019. (accessed May 19 2022) from: https://www.nist.gov/dads/HTML/redblack.html</ref> एवीएल पेड़ का आविष्कार जॉर्जी एडेल्सन वेलेस्की और ईव्जेनी लैन्ड्स द्वारा 1962 में सूचना के कुशल संगठन के लिए किया गया था।<ref>{{cite web|url=https://www.cs.cornell.edu/courses/cs312/2008sp/lectures/lec_avl.html|publisher=[[Cornell University]], Department of Computer Science|access-date=19 May 2022|title=CS 312 Lecture: AVL Trees|first=Andrew|last=Myers|url-status=live|archive-url=https://web.archive.org/web/20210427195749/http://www.cs.cornell.edu/courses/cs312/2008sp/lectures/lec_avl.html|archive-date=27 April 2021}}</ref><ref>{{cite journal|last1=Adelson-Velsky|first1=Georgy|last2=Landis|first2=Evgenii|year=1962|title=सूचना के संगठन के लिए एक एल्गोरिथ्म|journal=[[Proceedings of the USSR Academy of Sciences]]|volume=146|pages=263–266|language=ru}} [https://zhjwpku.com/assets/pdf/AED2-10-avl-paper.pdf English translation] by Myron J. Ricci in ''Soviet Mathematics - Doklady'', 3:1259–1263, 1962.</ref> यह आविष्कार किया जाने वाला पहला स्व-संतुलन बाइनरी खोजक पेड़  था।<ref>{{cite web|url=http://www.cs.toronto.edu/~toni/Courses/263-2015/lectures/lec04-balanced-augmentation.pdf|access-date=19 May 2022|url-status=live|archive-url=https://web.archive.org/web/20190214212633/http://www.cs.toronto.edu/~toni/Courses/263-2015/lectures/lec04-balanced-augmentation.pdf|title=CSC263: Balanced BSTs, AVL tree|first=Toniann|last=Pitassi|year=2015|publisher=[[University of Toronto]], Department of Computer Science|archive-date=14 February 2019|page=6}}</ref>
}}</ref> जैसे एवीएल ट्री [[ट्रीप]] और लाल काले ट्री <ref>Paul E. Black, "red-black tree", in Dictionary of Algorithms and Data Structures [online], Paul E. Black, ed. 12 November 2019. (accessed May 19 2022) from: https://www.nist.gov/dads/HTML/redblack.html</ref> एवीएल का आविष्कार जॉर्जी एडेल्सन वेलेस्की और ईव्जेनी लैन्ड्स द्वारा 1962 में सूचना के कुशल संगठन के लिए किया गया था<ref>{{cite web|url=https://www.cs.cornell.edu/courses/cs312/2008sp/lectures/lec_avl.html|publisher=[[Cornell University]], Department of Computer Science|access-date=19 May 2022|title=CS 312 Lecture: AVL Trees|first=Andrew|last=Myers|url-status=live|archive-url=https://web.archive.org/web/20210427195749/http://www.cs.cornell.edu/courses/cs312/2008sp/lectures/lec_avl.html|archive-date=27 April 2021}}</ref><ref>{{cite journal|last1=Adelson-Velsky|first1=Georgy|last2=Landis|first2=Evgenii|year=1962|title=सूचना के संगठन के लिए एक एल्गोरिथ्म|journal=[[Proceedings of the USSR Academy of Sciences]]|volume=146|pages=263–266|language=ru}} [https://zhjwpku.com/assets/pdf/AED2-10-avl-paper.pdf English translation] by Myron J. Ricci in ''Soviet Mathematics - Doklady'', 3:1259–1263, 1962.</ref> यह आविष्कार किया जाने वाला पहला स्व-संतुलन बाइनरी सर्च ट्री था।<ref>{{cite web|url=http://www.cs.toronto.edu/~toni/Courses/263-2015/lectures/lec04-balanced-augmentation.pdf|access-date=19 May 2022|url-status=live|archive-url=https://web.archive.org/web/20190214212633/http://www.cs.toronto.edu/~toni/Courses/263-2015/lectures/lec04-balanced-augmentation.pdf|title=CSC263: Balanced BSTs, AVL tree|first=Toniann|last=Pitassi|year=2015|publisher=[[University of Toronto]], Department of Computer Science|archive-date=14 February 2019|page=6}}</ref>




== सिंहावलोकन ==
== सिंहावलोकन ==
एक [[ द्विआधारी खोज ]]पेड़ एक कडा़ई बाइनरी पेंड़ है जिसमें नोड्स को एक क्रम में व्यवस्थित किया जाता है सख्त और गैर-सख्त क्रम जिसमें किसी विशेष कुंजियों वाले वृक्ष शब्दावली उप-वृक्ष या उससे कम संग्रहीत होते हैं जो बाइनरी खोज संपत्ति को संतुष्ट करते हैं।<ref name="reema18">{{cite book|title= सी का उपयोग कर डेटा संरचनाएं|date=13 October 2018|edition=2|first=Reema|last=Thareja|publisher=[[Oxford University Press]]|url=https://global.oup.com/academic/product/data-structures-using-c-9780198099307|isbn= 9780198099307|url-access=subscription|chapter=Hashing and Collision}}</ref>{{rp|p=298}}<ref name="algo_cormen">{{cite book|last1=Cormen|first1=Thomas H. |author-link1=Thomas H. Cormen|last2=Leiserson|first2=Charles E. |author-link2=Charles E. Leiserson|last3=Rivest|first3=Ronald L. |author-link3=Ronald L. Rivest|author-link4=Clifford Stein|first4=Clifford |last4=Stein|url=https://mitpress.mit.edu/books/introduction-algorithms-second-edition|title=एल्गोरिदम का परिचय|edition=2nd|year=2001|publisher=[[MIT Press]]|isbn=0-262-03293-7}}</ref>{{rp|287}}
[[ द्विआधारी खोज |बाइनरी सर्च ट्री]] एक पाठ्यक्रम है जिसमें नोड्स को एक क्रम में व्यवस्थित किया जाता है ये गैर-सख्त क्रम में रखे जाते हैं जिसमें किसी विशेष कुंजियों वाले बाइनरी सर्च ट्री से संग्रहित होते हैं तथा जो बाइनरी सर्च को संतुष्ट करते हैं।<ref name="reema18">{{cite book|title= सी का उपयोग कर डेटा संरचनाएं|date=13 October 2018|edition=2|first=Reema|last=Thareja|publisher=[[Oxford University Press]]|url=https://global.oup.com/academic/product/data-structures-using-c-9780198099307|isbn= 9780198099307|url-access=subscription|chapter=Hashing and Collision}}</ref>{{rp|p=298}}<ref name="algo_cormen">{{cite book|last1=Cormen|first1=Thomas H. |author-link1=Thomas H. Cormen|last2=Leiserson|first2=Charles E. |author-link2=Charles E. Leiserson|last3=Rivest|first3=Ronald L. |author-link3=Ronald L. Rivest|author-link4=Clifford Stein|first4=Clifford |last4=Stein|url=https://mitpress.mit.edu/books/introduction-algorithms-second-edition|title=एल्गोरिदम का परिचय|edition=2nd|year=2001|publisher=[[MIT Press]]|isbn=0-262-03293-7}}</ref>{{rp|287}}
 
[[खोज एल्गोरिदम|खोज प्रारूप]] को छोटा करने में बाइनरी सर्च ट्री प्रभावशाली है जिसमें कार्यान्वित आदेश और पहचान करने की आवश्यकता नहीं होती है जबकि बीएसटी की खोज जटिलता के उस क्रम पर निर्भर करती है जिसमें नोड्स डाले और हटाए जाते हैं जिससे कि खराब स्थिति बाइनरी सर्च ट्री में क्रमिक संचालन अर्धपतन का कारण बन जाता है और संरचना की तरह एक एकल  [[लिंक्ड सूची|सूची]] बना सकता है इस प्रकार सूची के रूप में सबसे खराब स्थिति वाली जटिलता में संग्रहित किया जाता है।<ref>{{cite journal|journal=[[The Computer Journal]]|volume=25|issue=1|date=1 February 1982|doi=10.1093/comjnl/25.1.158|author1=R. A. Frost|author2=M. M. Peterson|page=158|url=https://academic.oup.com/comjnl/article/25/1/158/527326|publisher=[[Oxford University Press]]|title=A Short Note on Binary Search Trees}}</ref>{{r|reema18|p=299-302}}
 
बाइनरी सर्च ट्री भी एक मूलभूत डेटा संरचना है जिसका उपयोग अमूर्त डेटा संरचनाओं जैसे सेट कंप्यूटर विज्ञान और साहचर्य सारणियों के निर्माण में किया जाता है।
 
 
 
 
 
 
 
 


[[खोज एल्गोरिदम|खोज प्रारूप]] को छोटा करने में बाइनरी सर्च पेड़ भी प्रभावशाली हैं। (इस प्रकार कार्यान्वित आदेश संबंध को सख्त और पहचान करने की आवश्यकता नहीं है) जबकि बीएसटी की खोज जटिलता से उस क्रम पर निर्भर करती है जिसमें नोड्स डाले और हटाए जाते हैं जिससे कि खराब स्थिति में बाइनरी सर्च पेंड़ में क्रमिक संचालन अर्धपतन का कारण बन सकता है और संरचना की तरह एक एकल [[लिंक्ड सूची]] बन सकती है इस प्रकार सूची के रूप में सबसे खराब स्थिति वाली एक जटिलता है।<ref>{{cite journal|journal=[[The Computer Journal]]|volume=25|issue=1|date=1 February 1982|doi=10.1093/comjnl/25.1.158|author1=R. A. Frost|author2=M. M. Peterson|page=158|url=https://academic.oup.com/comjnl/article/25/1/158/527326|publisher=[[Oxford University Press]]|title=A Short Note on Binary Search Trees}}</ref>{{r}}


बाइनरी सर्च पेंड़ भी एक मूलभूत डेटा संरचना है जिसका उपयोग अमूर्त डेटा संरचनाओं जैसे सेट कंप्यूटर विज्ञान और साहचर्य सारणियों के निर्माण में किया जाता है।


== संचालन ==
== संचालन ==


===खोजना===
===खोजना===
एक विशिष्ट कुंजी के लिए बाइनरी सर्च पेंड़ में खोज को क्रमादेशित पुनरावर्तन या पुनरावृत्ति गणना की जा सकती है।
एक विशिष्ट कुंजी के लिए बाइनरी सर्च ट्री को क्रमादेशित किया जाता है तथा इसमें पुनरावर्तन या पुनरावृत्ति की गणना की जाती है।


वृक्ष (डेटा संरचना) लकड़ी की जांच से खोज शुरू होती है अगर पेड़ नल बिन्दु हैं तो यह कुंजी रूट के बराबर है तो खोज सफल होती है और नोड वापस आ जाता है। यदि कुंजी रूट से कम है तो खोज बाएँ उप पेंड़ की जाँच करके आगे बढ़ती है इसी तरह यदि कुंजी रूट से अधिक है तो खोज हो चुकी होती है। यह प्रक्रिया तब तक दोहराई जाती है जब तक कि कुंजी मिल नहीं जाती या शेष उप पेंड़ नहीं मिल जाते यदि खोजी गई कुंजी नहीं मिलती तो कुंजी पेंड़ में नहीं है।{{r}}
बाइनरी सर्च ट्री की डेटा संरचना में लकड़ी की जांच की खोज शुरू होती है अगर सर्च ट्री नल बिन्दु कुंजी रूट के बराबर है तो खोज सफल होगी और नोड वापस आ जाता है यदि कुंजी रूट से कम है तो खोज बाएँ ट्री की जाँच करके आगे बढ़ती है इसी तरह यदि कुंजी रूट से अधिक है तो खोज हो चुकी होती है यह प्रक्रिया तब तक दोहराई जाती है जब तक कि कुंजी मिल नहीं जाती या शेष सर्च ट्री नहीं मिल जाता यदि खोजी गई कुंजी नहीं मिलती तो कुंजी सर्च ट्री में नहीं होती है।{{r|algo_cormen|pp=290-291}}


==== पुनरावर्ती खोज ====
==== पुनरावर्ती खोज ====
निम्नलिखित [[स्यूडोकोड]] पुनरावर्तन (कंप्यूटर विज्ञान) के माध्यम से बी टी एस खोज प्रक्रिया को लागू करता है।<ref name="algo_cormen" />{{rp}}
निम्नलिखित [[स्यूडोकोड]] पुनरावर्तन कंप्यूटर विज्ञान के माध्यम से बीटीएस खोज प्रक्रिया को लागू करता है।<ref name="algo_cormen" />{{rp}}


==== पुनरावृत्त खोज ====
==== पुनरावृत्त खोज ====
खोज के पुनरावर्ती संस्करण को थोड़ी देर के लूप में अनियंत्रित किया जा सकता है अधिकांश मशीनों पर पुनरावृत्त संस्करण अधिक कंप्यूटर प्रदर्शन वाला पाया जाता है।<ref name="algo_cormen" />{{rp|291}}
खोज के पुनरावर्ती संस्करण को कुछ समय में नियंत्रित किया जा सकता है क्योंकि अधिकांश मशीनों पर पुनरावृत्त संस्करण कंप्यूटर प्रदर्शन में पाया जाता है।<ref name="algo_cormen" />{{rp|291}}


इसमें खोज के कुछ [[ लसीका नोड |लसीका नोड]] होते हैं बीएसटी खोज की दौड़ समय जटिल है जबकि बीएसटी खोज के लिए सबसे खराब स्थिति बीएसटी में नोड्स की कुल संख्या एन है क्योंकि एक असंतुलित बीएसटी एक लिंक्ड सूची में खराब हो सकता है जबकि बीटीएस [[ऊँचाई-संतुलित वृक्ष]] है | ऊँचाई-संतुलित है।<ref name="algo_cormen" />{{rp}}
इसमें खोज के कुछ [[ लसीका नोड |लसीका नोड]] होते हैं बीएसटी खोज की दौड़ कठिन होती है जबकि बीएसटी खोज की सबसे खराब स्थिति होती है तथा बीएसटी में नोड्स की कुल संख्या एन है क्योंकि एक असंतुलित बीएसटी एक सूची में खराब हो सकती है जबकि बीटीएस [[ऊँचाई-संतुलित वृक्ष|ऊँचाई-संतुलित सर्च ट्री]] है ।<ref name="algo_cormen" />{{rp}}


==== उत्तराधिकारी और पूर्ववर्ती ====
==== पूर्ववर्ती उत्तराधिकारी ====
कुछ कार्यों के लिए एक नोड दिया गया जिसके उत्तराधिकारी या पूर्ववर्ती का पता लगाना अत्यंत महत्वपूर्ण है यह मानते हुए कि बीएसटी की सभी कुंजियाँ अलग-अलग हैं तथा एक नोड के उत्तराधिकारी हैं बीएसटी में सबसे छोटी कुंजी वाला नोड एक्स है दूसरी ओर एक नोड के पूर्ववर्ती बीएसटी में सबसे बड़ी कुंजी से छोटा नोड एक्स है नोड के उत्तराधिकारी और पूर्ववर्ती को खोजने के लिए निम्नलिखित स्यूडोकोड हैं-
कुछ कार्यों के लिए एक नोड दिया गया जिसके उत्तराधिकारी या पूर्ववर्ती का पता लगाना अत्यंत महत्वपूर्ण है जबकि बीएसटी की सभी कुंजियाँ अलग-अलग हैं तथा एक नोड के उत्तराधिकारी हैं बीएसटी में सबसे छोटी कुंजी वाला नोड एक्स है दूसरी ओर एक नोड के पूर्ववर्ती बीएसटी में सबसे बड़ी कुंजी से छोटा नोड एक्स है नोड के उत्तराधिकारी और पूर्ववर्ती को खोजने के लिए निम्नलिखित स्यूडोकोड की प्रयोग किया जाता है।


<ref>{{cite web|url=https://ranger.uta.edu/~huang/teaching/CSE5311/CSE5311_Lecture10.pdf|archive-url=https://web.archive.org/web/20210413045057/http://ranger.uta.edu/~huang/teaching/CSE5311/CSE5311_Lecture10.pdf|archive-date=13 April 2021|page=12|publisher=[[University of Texas at Arlington]]|access-date=17 May 2021|url-status=live|title=एल्गोरिदम का डिजाइन और विश्लेषण|author=Junzhou Huang}}</ref><ref>{{cite web |author=Ray |first=Ray |title=बाइनरी सर्च ट्री|url=https://cs.lmu.edu/~ray/notes/binarysearchtrees/ |access-date=17 May 2022 |publisher=[[Loyola Marymount University]], Department of Computer Science}}</ref><ref name="algo_cormen" />{{rp}}
<ref>{{cite web|url=https://ranger.uta.edu/~huang/teaching/CSE5311/CSE5311_Lecture10.pdf|archive-url=https://web.archive.org/web/20210413045057/http://ranger.uta.edu/~huang/teaching/CSE5311/CSE5311_Lecture10.pdf|archive-date=13 April 2021|page=12|publisher=[[University of Texas at Arlington]]|access-date=17 May 2021|url-status=live|title=एल्गोरिदम का डिजाइन और विश्लेषण|author=Junzhou Huang}}</ref><ref>{{cite web |author=Ray |first=Ray |title=बाइनरी सर्च ट्री|url=https://cs.lmu.edu/~ray/notes/binarysearchtrees/ |access-date=17 May 2022 |publisher=[[Loyola Marymount University]], Department of Computer Science}}</ref><ref name="algo_cormen" />{{rp}}


बीएसटी में एक नोड खोजने जैसे संचालन, जिसकी कुंजी अधिकतम या न्यूनतम है, कुछ कार्यों में महत्वपूर्ण हैं, जैसे कि उत्तराधिकारी और नोड्स के पूर्ववर्ती का निर्धारण करना। संचालन के लिए स्यूडोकोड निम्नलिखित है।<ref name="algo_cormen" />{{rp|291–292}}
बीएसटी में एक नोड खोजने के लिए संचालन जिसकी कुंजी सीमा अधिकतम या न्यूनतम है यह कुछ कार्यों में महत्वपूर्ण हैं जैसे कि उत्तराधिकारी और नोड्स के पूर्ववर्ती का निर्धारण करना संचालन के लिए स्यूडोकोड महत्वपूर्ण हैं।<ref name="algo_cormen" />{{rp|291–292}}
 
 
 
 
 
 
 
 






=== प्रविष्टि ===
=== प्रविष्टि ===
सम्मिलन और विलोपन जैसे संचालन बीएसटी प्रतिनिधित्व को गतिशील रूप से बदलने का कारण बनते हैं डेटा संरचना को इस तरह से संशोधित किया जाना चाहिए कि बीएसटी के गुण बने रहें और बीएसटी में [[पत्ती के नोड्स]] के रूप में नए नोड डाले गए हैं।<ref name="algo_cormen" />{{rp}} सम्मिलित ऑपरेशन का पुनरावृत्त कार्यान्वयन है।<ref name="algo_cormen" />{{rp}}
सम्मिलन और विलोपन संचालन बीएसटी प्रतिनिधित्व को गतिशील रूप से बदलने का कारण बनते हैं डेटा संरचना को इस तरह से संशोधित किया जाता है जिससे कि बीएसटी के गुण बने रहें बीएसटी में [[पत्ती के नोड्स]] के रूप में नए नोड डाले जाते हैं <ref name="algo_cormen" />{{rp}}जो सम्मिलित ऑपरेशन की प्रविष्टि करते हैं।<ref name="algo_cormen" />{{rp}}


=== हटाना ===
=== हटाना ===
एक नोड का विलोपन, कहते हैं <math>\mathsf{D}</math>, एक बाइनरी सर्च ट्री से <math>\mathsf{BST}</math> तीन मामलों का पालन करना चाहिए:{{r|algo_cormen|p=295}}
यह एक नोड का विलोपन है जो एक बाइनरी सर्च ट्री से बीएसटी की तीन स्थितियों का पालन करते हैं।{{r|algo_cormen|p=295}}
# अगर <math>\mathsf{D}</math> एक लीफ नोड है, जो पैरेंट नोड का पॉइंटर है <math>\mathsf{D}</math> से प्रतिस्थापित हो जाता है <math>\mathsf{NIL}</math> और इसके परिणामस्वरूप <math>\mathsf{D}</math> पेड़ से हटा दिया जाता है।
# माना डी एक पत्ती है जो डी का मूल बिन्दु है डी सर्च ट्री से हटा दिया जाता है।
# अगर <math>\mathsf{D}</math> एक एकल चाइल्ड नोड है, तो बच्चा या तो बाएँ या दाएँ बच्चे के रूप में उन्नत हो जाता है {{nowrap|<math>\mathsf{D}</math>′s}} माता-पिता की स्थिति के आधार पर <math>\mathsf{D}</math> बीएसटी के भीतर, जैसा कि अंजीर में दिखाया गया है। 2 भाग () और भाग (बी), और परिणामस्वरूप, <math>\mathsf{D}</math> पेड़ से हटा दिया जाता है।
# अगर डी एक एकल विद्यार्थी है तो बच्चा बाएँ या दाएँ बच्चे के रूप में उन्नत करेगा डी माता-पिता की स्थिति के आधार पर कार्य करता है जैसे अंजीर में दिखाया गया है कि भाग ए और भाग बी और डी पेड़ से हटा दिया जाता है।
# अगर <math>\mathsf{D}</math> का उत्तराधिकारी एक बाएँ और दाएँ दोनों बच्चे हैं <math>\mathsf{D}</math> (जाने भी दो <math>\mathsf{E}</math> जिसके पास कोई बच्चा नहीं है)) की स्थिति लेता है <math>\mathsf{D}</math> वृक्ष में। यह की स्थिति पर निर्भर करता है <math>\mathsf{E}</math> अंदर <math>\mathsf{BST}</math>:{{r|algo_cormen|p=296}}
# अगर डी का उत्तराधिकारी एक बाएँ और दाएँ दोनों बच्चे हैं जिसके पास कोई बच्चा नहीं है तो इस स्थिति में वह क्या करेगा।
##अगर <math>\mathsf{E}</math> है {{nowrap|<math>\mathsf{D}</math>′s}} तत्काल दायां बच्चा, <math>\mathsf{E}</math> ऊंचा हो जाता है और <math>\mathsf{E}</math>के लेफ्ट चाइल्ड पॉइंटर को पॉइंट किया जाता है {{nowrap|<math>\mathsf{D}</math>′s}} प्रारंभिक बाएँ उप-वृक्ष, जैसा कि चित्र में दिखाया गया है। 2 भाग (सी)।
##अगर डी एस का दायां बच्चा ऊंचा हो जाता है तो ई के बॉंये बच्चे किस बिन्दु पर ले जाये जायेंगे।
##अगर <math>\mathsf{E}</math> की तत्काल सही संतान नहीं है <math>\mathsf{D}</math>, विलोपन की स्थिति को बदलकर आगे बढ़ता है <math>\mathsf{E}</math> द्वारा {{nowrap|<math>\mathsf{E}</math>′s}} सही बच्चा (यहाँ <math>\mathsf{F}</math>), और <math>\mathsf{E}</math> का स्थान लेता है <math>\mathsf{D}</math> में <math>\mathsf{BST}</math>, जैसा कि यहां दिखाया गया है।
##
  &nbsp; &nbsp; &nbsp; [[File:AVL-tree-delete.svg|600px|नोड <math>\mathsf{D}</math> हटाने के लिए 2 बच्चे हैं]]
  &nbsp; &nbsp; &nbsp; [[File:AVL-tree-delete.svg|600px|नोड <math>\mathsf{D}</math> हटाने के लिए 2 बच्चे हैं]]
{{clear}}
{{clear}}
निम्नलिखित स्यूडोकोड बाइनरी सर्च ट्री में विलोपन ऑपरेशन को लागू करता है।{{r|algo_cormen|p=296-298}}
निम्नलिखित स्यूडोकोड बाइनरी सर्च ट्री में विलोपन ऑपरेशन को लागू करता है।{{r|algo_cormen|p=296-298}}
The following pseudocode implements the deletion operation in a binary search tree.{{r|algo_cormen|p=296-298}}
{|
{|
|- style="vertical-align:top"
|- style="vertical-align:top"
|
|
  1    BST_Delete(BST, D)
  1    BST-Delete(BST, D)
  2      '''if''' D.left = NIL '''then'''
  2      '''if''' D.left = NIL '''then'''
  3        Shift_Nodes(BST, D, D.right)
  3        Shift-Nodes(BST, D, D.right)
  4      '''else if''' D.right = NIL '''then'''
  4      '''else if''' D.right = NIL '''then'''
  5        Shift_Nodes(BST, D, D.left)
  5        Shift-Nodes(BST, D, D.left)
  6      '''else'''
  6      '''else'''
  7        E := Tree_Successor(D)
  7        E := Tree-Successor(D)
  8        '''if''' E.parent &ne; D '''then'''
  8        '''if''' E.parent &ne; D '''then'''
  9          Shift_Nodes(BST, E, E.right)
  9          Shift-Nodes(BST, E, E.right)
  10        E.right := D.right
  10        E.right := D.right
  11        E.right.parent := E
  11        E.right.parent := E
  12      '''end if'''
  12      '''end if'''
  13      Shift_Nodes(BST, D, E)
  13      Shift-Nodes(BST, D, E)
  14      E.left := D.left
  14      E.left := D.left
  15      E.left.parent := E
  15      E.left.parent := E
  16    '''end if'''
  16    '''end if'''
|
|
  1    Shift_Nodes(BST, u, v)
  1    Shift-Nodes(BST, u, v)
  2      '''if''' u.parent = NIL '''then'''
  2      '''if''' u.parent = NIL '''then'''
  3        BST.root := v
  3        BST.root := v
Line 97: Line 116:
  10    '''end if'''
  10    '''end if'''
|}
|}
<math>\mathsf{Tree\_Delete}</math> h> प्रक्रिया ऊपर उल्लिखित 3 विशेष मामलों से संबंधित है। पंक्तियाँ 2-3 केस 1 से संबंधित हैं; पंक्ति 4-5 स्थिति 2 से संबंधित है और पंक्ति 6-16 स्थिति 3 के लिए है। सहायक कार्य <math>\mathsf{Shift\_Nodes}</math> नोड को बदलने के उद्देश्य से विलोपन एल्गोरिथ्म के भीतर उपयोग किया जाता है <math>\mathsf{u}</math> साथ <math>\mathsf{v}</math> बाइनरी सर्च ट्री में <math>\mathsf{BST}</math>.{{r|algo_cormen|p=298}} यह प्रक्रिया हटाने (और प्रतिस्थापन) को संभालती है <math>\mathsf{u}</math> से <math>\mathsf{BST}</math>.
The <math>\text{Tree-Delete}</math> procedure deals with the 3 special cases mentioned above. Lines 2-3 deal with case 1; lines 4-5 deal with case 2 and lines 6-16 for case 3. The [[helper function]] <math>\text{Shift-Nodes}</math> is used within the deletion algorithm for the purpose of replacing the node <math>\text{u}</math> with <math>\text{v}</math> in the binary search tree <math>\text{BST}</math>.{{r|algo_cormen|p=298}} This procedure handles the deletion (and substitution) of <math>\text{u}</math> from <math>\text{BST}</math>.
 
 
 
 
 


== ट्रैवर्सल ==
{{Main article|Tree traversal}}
{{see also|Threaded binary tree}}
एक BST तीन बुनियादी एल्गोरिदम के माध्यम से [[ट्री ट्रैवर्सल]] हो सकता है: [[इनऑर्डर ट्रैवर्सल]], [[प्री-ऑर्डर ट्रैवर्सल]] और [[पोस्ट-ऑर्डर ट्रैवर्सल]] ट्री वॉक।<ref name="algo_cormen" />{{rp|287}}
* इनऑर्डर ट्री वॉक: बाएं सबट्री से नोड्स पहले देखे जाते हैं, उसके बाद रूट नोड और राइट सबट्री।
*प्रीऑर्डर ट्री वॉक: रूट नोड को पहले विज़िट किया जाता है, उसके बाद बाएँ और दाएँ सबट्री को देखा जाता है।
* पोस्टऑर्डर ट्री वॉक: बाएं सबट्री से नोड्स पहले देखे जाते हैं, उसके बाद राइट सबट्री और अंत में रूट।


ट्री वॉक का पुनरावर्ती कार्यान्वयन निम्नलिखित है।<ref name="algo_cormen" />{{rp|287–289}}
 
{|
 
|- style="vertical-align:top"
 
|
 
  Inorder-Tree-Walk(x)
== यात्रीगण ==
    '''if''' x &ne; NIL '''then'''
{{see also|थ्रेडेड बाइनरी ट्री}}
      Inorder-Tree-Walk(x.left)
एक बीएसटी तीन बुनियादी प्रारूप के माध्यम से [[ट्री ट्रैवर्सल|यात्रा]] हो सकती है [[इनऑर्डर ट्रैवर्सल|यात्रा में आदेश]] [[प्री-ऑर्डर ट्रैवर्सल|उप आदेशिक यात्रा]] और [[पोस्ट-ऑर्डर ट्रैवर्सल|पोस्ट आदेश यात्रायें]] भी सम्मिलित हैं।<ref name="algo_cormen" />{{rp}}
      ''visit node''
* बाएं सर्च ट्री से नोड्स पहले देखे जाते हैं उसके बाद रूट देखे जाते हैं।
      Inorder-Tree-Walk(x.right)
*जड़ को पहले बहाया जाता है उसके बाद बाएँ और दाएँ सर्च ट्री को देखा जाता है।
    '''end if'''
* बाएं सर्च ट्री से नोड्स पहले देखे जाते हैं।
|
 
  Preorder-Tree-Walk(x)
    '''if''' x &ne; NIL '''then'''
      ''visit node''
      Preorder-Tree-Walk(x.left)
      Preorder-Tree-Walk(x.right)
    '''end if'''
|
  Postorder-Tree-Walk(x)
    '''if''' x &ne; NIL '''then'''
      Postorder-Tree-Walk(x.left)
      Postorder-Tree-Walk(x.right)
      ''visit node''
    '''end if'''
|}




== संतुलित बाइनरी सर्च ट्री ==
== संतुलित बाइनरी सर्च ट्री ==
{{Main|Self-balancing binary search tree}}
{{Main|सेल्फ-बैलेंसिंग बाइनरी सर्च ट्री}}
पुनर्संतुलन के बिना, बाइनरी सर्च ट्री में सम्मिलन या विलोपन अध: पतन का कारण बन सकता है, जिसके परिणामस्वरूप ऊँचाई होती है <math>n</math> पेड़ की (जहां <math>n</math> एक पेड़ में वस्तुओं की संख्या है), ताकि लुकअप प्रदर्शन एक रेखीय खोज की तुलना में खराब हो जाए।<ref>{{cite web|url=https://www.ics.uci.edu/~thornton/ics46/Notes/BinarySearchTrees/|publisher=[[University of California, Irvine]]|year=2021|first=Alex|last=Thornton|title= ICS 46: Binary Search Trees|archive-url=https://web.archive.org/web/20210704141729/https://www.ics.uci.edu/~thornton/ics46/Notes/BinarySearchTrees/|archive-date=4 July 2021|url-status=live|access-date=21 October 2021}}</ref> खोज वृक्ष को संतुलित और ऊँचाई से घिरा रखना <math>O(\log n)</math> बाइनरी सर्च ट्री की उपयोगिता की कुंजी है। बाइनरी लॉगरिदमिक जटिलता के लिए पेड़ की ऊंचाई को बनाए रखने के लिए डिज़ाइन किए गए पेड़ के अद्यतन संचालन के दौरान इसे स्व-संतुलन तंत्र द्वारा प्राप्त किया जा सकता है।<ref name="Knuth98" /><ref name="peter11">{{cite book|publisher=[[Cambridge University Press]]|url=https://www.cambridge.org/core/books/advanced-data-structures/D56E2269D7CEE969A3B8105AD5B9254C|title=उन्नत डेटा संरचना|date=January 2011|isbn=9780511800191|doi=10.1017/CBO9780511800191|first=Peter|last=Brass}}</ref>{{rp|p=50}}
पुनर्संतुलन के बिना बाइनरी सर्च ट्री में सम्मिलित या विलोपन अर्धपतन का कारण बन सकता है जिसके परिणामस्वरूप ऊँचाई होती है एक रेखीय खोज की तुलना में सर्च ट्री को संतुलित और ऊँचाई से घेरे रखना होता है बाइनरी प्रारूप जटिलता के लिए बाइनरी सर्च ट्री की ऊंचाई को बनाए रखने के लिए बनावट किए गए ट्री के अद्यतन संचालन के दौरान इसे स्व-संतुलन तंत्र द्वारा प्राप्त किया जा सकता है।<ref name="Knuth98" /><ref name="peter11">{{cite book|publisher=[[Cambridge University Press]]|url=https://www.cambridge.org/core/books/advanced-data-structures/D56E2269D7CEE969A3B8105AD5B9254C|title=उन्नत डेटा संरचना|date=January 2011|isbn=9780511800191|doi=10.1017/CBO9780511800191|first=Peter|last=Brass}}</ref>{{rp}}
 
=== ऊंचाई-संतुलित ट्री ===
एक सर्च ट्री ऊँचाई-संतुलित में होता है यदि बाइनरी सर्च ट्री की ऊँचाइयों को एक स्थिर कारक द्वारा संबंधित होने दिया जाता है। यह संपत्ति एवीएल ट्री द्वारा पेश की गई थी और लाल-काले ट्री द्वारा जारी रखी गई थी।{{r|peter11|pp=50-51}}जड़ से संशोधित पत्ती तक पथ पर सभी की ऊंचाई को देखी जानी चाहिए और संभवतया ट्री में प्रत्येक डाल को हटाने के लिए सही किया जाना चाहिए।{{r|peter11|pp=52}}
 
 
 
 
 
 
 
 
 
 
 
=== वजन-संतुलित ट्री ===
{{main|वजन संतुलित ट्री}}
भार-संतुलित ट्री में संतुलित ट्री की कसौटी की पत्तियों की संख्या है बाएँ और दाएँ सर्च ट्री का वजन सबसे अधिक होता है <ref>{{Cite journal|doi=10.1016/0304-3975(80)90018-3|title=वजन-संतुलित पेड़ों में पुनर्संतुलन संचालन की औसत संख्या पर|journal=Theoretical Computer Science|volume=11|issue=3|pages=303–320|year=1978|last1=Blum|first1=Norbert|last2=Mehlhorn|first2=Kurt|url=http://scidok.sulb.uni-saarland.de/volltexte/2011/4019/pdf/fb14_1978_06.pdf |archive-url=https://ghostarchive.org/archive/20221009/http://scidok.sulb.uni-saarland.de/volltexte/2011/4019/pdf/fb14_1978_06.pdf |archive-date=2022-10-09 |url-status=live}}</ref>{{r|peter11|pp=61}} जबकि अंतर अनुपात से बंधा हुआ है अल्फा संतुलन की स्थिति के बाद नहीं रखा जा सकता सर्च ट्री संतुलन की स्थिति का एक पूरा परिवार होता है जहां प्रत्येक सर्च ट्री में कम से कम एक अंश होता है।{{r|peter11|pp=62}}
 
 
 
 
 
 
 
 


=== ऊंचाई-संतुलित पेड़ ===
एक पेड़ ऊँचाई-संतुलित होता है यदि बाएँ उप-वृक्ष और दाएँ उप-वृक्ष की ऊँचाइयों को एक स्थिर कारक द्वारा संबंधित होने की गारंटी दी जाती है। यह संपत्ति एवीएल पेड़ द्वारा पेश की गई थी और लाल-काले पेड़ द्वारा जारी रखी गई थी।{{r|peter11|pp=50-51}} रूट से संशोधित लीफ नोड तक पथ पर सभी नोड्स की ऊंचाई को देखा जाना चाहिए और संभवतया पेड़ में प्रत्येक डालने और हटाने के ऑपरेशन पर सही किया जाना चाहिए।{{r|peter11|pp=52}}


=== वजन-संतुलित पेड़ ===
{{main|Weight-balanced tree}}
भार-संतुलित वृक्ष में, संतुलित वृक्ष की कसौटी उपवृक्षों की पत्तियों की संख्या है। बाएँ और दाएँ सबट्री का वज़न सबसे अधिक भिन्न होता है <math>1</math>.<ref>{{Cite journal|doi=10.1016/0304-3975(80)90018-3|title=वजन-संतुलित पेड़ों में पुनर्संतुलन संचालन की औसत संख्या पर|journal=Theoretical Computer Science|volume=11|issue=3|pages=303–320|year=1978|last1=Blum|first1=Norbert|last2=Mehlhorn|first2=Kurt|url=http://scidok.sulb.uni-saarland.de/volltexte/2011/4019/pdf/fb14_1978_06.pdf |archive-url=https://ghostarchive.org/archive/20221009/http://scidok.sulb.uni-saarland.de/volltexte/2011/4019/pdf/fb14_1978_06.pdf |archive-date=2022-10-09 |url-status=live}}</ref>{{r|peter11|pp=61}} हालांकि, अंतर एक अनुपात से बंधा हुआ है <math>\alpha</math> वजन की, एक मजबूत संतुलन की स्थिति के बाद से <math>1</math> के साथ नहीं रखा जा सकता <math>O(\log n)</math> डालने और हटाने के संचालन के दौरान पुनर्संतुलन कार्य। <math>\alpha</math>वें>-वजन-संतुलित पेड़ संतुलन की स्थिति का एक पूरा परिवार देता है, जहां प्रत्येक बाएँ और दाएँ सबट्री में कम से कम एक अंश होता है <math>\alpha</math> सबट्री के कुल वजन का।{{r|peter11|pp=62}}


=== प्रकार ===
=== प्रकार ===
कई स्व-संतुलित बाइनरी सर्च ट्री हैं, जिनमें [[टी पेड़]],<ref>{{cite conference|url=https://archive.org/details/verylargedatabas0000inte|first1=Tobin J.|last1=Lehman|first2=Michael J.|last2=Carey|title=मेन मेमोरी डेटाबेस मैनेजमेंट सिस्टम्स के लिए इंडेक्स स्ट्रक्चर्स का अध्ययन|location=Kyoto|date=25–28 August 1986|conference=Twelfth International Conference on Very Large Databases (VLDB 1986)|isbn=0-934613-18-4|url-access=registration}}</ref> ट्रीप,<ref>{{Citation | contribution=Randomized Search Trees | first1=Cecilia R. | last1=Aragon | first2=Raimund | last2=Seidel | contribution-url=http://faculty.washington.edu/aragon/pubs/rst89.pdf |archive-url=https://ghostarchive.org/archive/20221009/http://faculty.washington.edu/aragon/pubs/rst89.pdf |archive-date=2022-10-09 |url-status=live | title=Proc. 30th Symp. Foundations of Computer Science (FOCS 1989) | pages=540–545 | year=1989 | doi=10.1109/SFCS.1989.63531 | isbn=0-8186-1982-1 | publisher=IEEE Computer Society Press | location=Washington, D.C.| title-link=Symposium on Foundations of Computer Science }}</ref> लाल-काले पेड़,<ref name="Cormen2001">{{Anchor|Cormen}}{{Cite book |title=Introduction to Algorithms |last1=Cormen |first1=Thomas H. |author1-link=Thomas H. Cormen |last2=Leiserson |first2=Charles E. |author2-link=Charles E. Leiserson |last3=Rivest |first3=Ronald L. |author3-link=Ronald L. Rivest |last4=Stein |first4=Clifford |author4-link=Clifford Stein |edition=second |publisher=MIT Press |year=2001 |isbn=978-0-262-03293-3 |chapter=Red&ndash;Black Trees |pages=[https://archive.org/details/introductiontoal00corm_691/page/n735 273]–301 |title-link=Introduction to Algorithms }}</ref> बी-पेड़,<ref>{{Citation | last = Comer | first = Douglas | author-link = Douglas Comer | title = The Ubiquitous B-Tree | journal = Computing Surveys | volume = 11 | issue = 2 | pages = 123–137 | date = June 1979 | issn = 0360-0300 | doi = 10.1145/356770.356776 | s2cid = 101673 }}</ref> 2-3 पेड़,<ref>{{cite book| title=कंप्यूटर प्रोग्रामिंग की कला|volume=3| chapter=6.2.4 |quote=The 2–3 trees defined at the close of Section 6.2.3 are equivalent to B-Trees of order 3. |first1=Donald M |last1=Knuth |edition=2 |isbn=9780201896855 |publisher=Addison Wesley|year=1998}}</ref> और [[ स्प्ले पेड़ ]]।<ref>{{cite journal | first1 = Daniel D. | last1 = Sleator | author1-link = Daniel Sleator | first2 = Robert E. | last2 = Tarjan | author2-link = Robert Tarjan | title = स्व-समायोजन बाइनरी खोज पेड़| journal = [[Journal of the ACM]] | volume = 32 | issue = 3 | pages = 652–686 | year = 1985 | url = https://www.cs.cmu.edu/~sleator/papers/self-adjusting.pdf | doi = 10.1145/3828.3835 | s2cid = 1165848 }}</ref>
कई स्व-संतुलित बाइनरी सर्च ट्री हैं जिनमें <ref>{{cite conference|url=https://archive.org/details/verylargedatabas0000inte|first1=Tobin J.|last1=Lehman|first2=Michael J.|last2=Carey|title=मेन मेमोरी डेटाबेस मैनेजमेंट सिस्टम्स के लिए इंडेक्स स्ट्रक्चर्स का अध्ययन|location=Kyoto|date=25–28 August 1986|conference=Twelfth International Conference on Very Large Databases (VLDB 1986)|isbn=0-934613-18-4|url-access=registration}}</ref> <ref>{{Citation | contribution=Randomized Search Trees | first1=Cecilia R. | last1=Aragon | first2=Raimund | last2=Seidel | contribution-url=http://faculty.washington.edu/aragon/pubs/rst89.pdf |archive-url=https://ghostarchive.org/archive/20221009/http://faculty.washington.edu/aragon/pubs/rst89.pdf |archive-date=2022-10-09 |url-status=live | title=Proc. 30th Symp. Foundations of Computer Science (FOCS 1989) | pages=540–545 | year=1989 | doi=10.1109/SFCS.1989.63531 | isbn=0-8186-1982-1 | publisher=IEEE Computer Society Press | location=Washington, D.C.| title-link=Symposium on Foundations of Computer Science }}</ref> रेड-ब्लैक ट्री<ref name="Cormen2001">{{Anchor|Cormen}}{{Cite book |title=Introduction to Algorithms |last1=Cormen |first1=Thomas H. |author1-link=Thomas H. Cormen |last2=Leiserson |first2=Charles E. |author2-link=Charles E. Leiserson |last3=Rivest |first3=Ronald L. |author3-link=Ronald L. Rivest |last4=Stein |first4=Clifford |author4-link=Clifford Stein |edition=second |publisher=MIT Press |year=2001 |isbn=978-0-262-03293-3 |chapter=Red&ndash;Black Trees |pages=[https://archive.org/details/introductiontoal00corm_691/page/n735 273]–301 |title-link=Introduction to Algorithms }}</ref> भी होते हैं।
 




Line 152: Line 176:


=== क्रमबद्ध करें ===
=== क्रमबद्ध करें ===
{{Main article|Tree sort}}
{{Main article|ट्री सॉर्ट}}
बाइनरी सर्च ट्री का उपयोग सॉर्टिंग एल्गोरिदम जैसे ट्री सॉर्ट में किया जाता है, जहां सभी तत्वों को एक ही बार में डाला जाता है और ट्री को इन-ऑर्डर फैशन में ट्रैवर्स किया जाता है।<ref>{{cite web|url=https://www.cs.princeton.edu/courses/archive/spring19/cos226/lectures/study/32BinarySearchTrees.html|publisher=[[Princeton University School of Engineering and Applied Science]]|first=Arvind|last=Narayanan|access-date=21 October 2021|title=COS226: Binary search trees|archive-url=https://web.archive.org/web/20210322040843/https://www.cs.princeton.edu/courses/archive/spring19/cos226/lectures/study/32BinarySearchTrees.html|archive-date=22 March 2021|url-status=live|year=2019|via=cs.princeton.edu}}</ref> BST का उपयोग [[जल्दी से सुलझाएं]] में भी किया जाता है।<ref>{{cite web|url=http://mathcenter.oxford.emory.edu/site/cs171/bstQuicksortConnection/|title=बाइनरी सर्च ट्री और क्विकसॉर्ट के बीच एक कनेक्शन|archive-url=https://web.archive.org/web/20210226103159/http://mathcenter.oxford.emory.edu/site/cs171/bstQuicksortConnection/|publisher=[[Oxford College of Emory University]], The Department of Mathematics and Computer Science|first=Li|last=Xiong|url-status=live|access-date=4 June 2022|archive-date=26 February 2021}}</ref>
बाइनरी सर्च ट्री का उपयोग में ट्री का प्रारूप छोटा किया जाता है जहां सभी तत्वों को एक ही बार में डाला जाता है।  




=== प्राथमिकता कतार संचालन ===
 
{{main|Priority queue}}
<ref>{{cite web|url=https://www.cs.princeton.edu/courses/archive/spring19/cos226/lectures/study/32BinarySearchTrees.html|publisher=[[Princeton University School of Engineering and Applied Science]]|first=Arvind|last=Narayanan|access-date=21 October 2021|title=COS226: Binary search trees|archive-url=https://web.archive.org/web/20210322040843/https://www.cs.princeton.edu/courses/archive/spring19/cos226/lectures/study/32BinarySearchTrees.html|archive-date=22 March 2021|url-status=live|year=2019|via=cs.princeton.edu}}</ref><ref>{{cite web|url=http://mathcenter.oxford.emory.edu/site/cs171/bstQuicksortConnection/|title=बाइनरी सर्च ट्री और क्विकसॉर्ट के बीच एक कनेक्शन|archive-url=https://web.archive.org/web/20210226103159/http://mathcenter.oxford.emory.edu/site/cs171/bstQuicksortConnection/|publisher=[[Oxford College of Emory University]], The Department of Mathematics and Computer Science|first=Li|last=Xiong|url-status=live|access-date=4 June 2022|archive-date=26 February 2021}}</ref>
बाइनरी सर्च ट्री का उपयोग [[प्राथमिकता कतार]]ों को लागू करने में किया जाता है, नोड की कुंजी को प्राथमिकताओं के रूप में उपयोग करते हुए। कतार में नए तत्व जोड़ना नियमित BST सम्मिलन ऑपरेशन का अनुसरण करता है लेकिन निष्कासन ऑपरेशन प्राथमिकता कतार के प्रकार पर निर्भर करता है:<ref>{{cite web|publisher=[[Cornell University]], [[Cornell University College of Engineering|Department of Computer Science]]|first=Andrew|last=Myers|title=CS 2112 Lecture and Recitation Notes: Priority Queues and Heaps|url=https://www.cs.cornell.edu/courses/cs4120/2016sp/lectures/lec_heaps/|archive-date=21 October 2021|url-status=live|archive-url=https://web.archive.org/web/20211021202727/https://www.cs.cornell.edu/courses/cs4120/2016sp/lectures/lec_heaps/|access-date=21 October 2021}}
 
 
 
=== प्राथमिकता पंक्ति संचालन ===
{{main|वरीयता कतार}}
बाइनरी सर्च ट्री का उपयोग [[प्राथमिकता कतार|प्राथमिक पंक्ति]] को लागू करने में किया जाता है कुंजी को प्राथमिकताओं के रूप में उपयोग करते हुए पंक्ति में नए तत्व में जोड़ना नियमित बीएसटी सम्मिलन ऑपरेशन का अनुसरण करता है लेकिन निष्कासन ऑपरेशन प्राथमिकता पंक्ति के प्रकार पर निर्भर करता है।<ref>{{cite web|publisher=[[Cornell University]], [[Cornell University College of Engineering|Department of Computer Science]]|first=Andrew|last=Myers|title=CS 2112 Lecture and Recitation Notes: Priority Queues and Heaps|url=https://www.cs.cornell.edu/courses/cs4120/2016sp/lectures/lec_heaps/|archive-date=21 October 2021|url-status=live|archive-url=https://web.archive.org/web/20211021202727/https://www.cs.cornell.edu/courses/cs4120/2016sp/lectures/lec_heaps/|access-date=21 October 2021}}
</ref>
</ref>
* यदि यह एक आरोही क्रम प्राथमिकता कतार है, तो सबसे कम प्राथमिकता वाले तत्व को BST के बाईं ओर ट्रैवर्सल के माध्यम से हटाया जाता है।
* यदि यह एक आरोही क्रम की प्राथमिक पंक्ति है तो सबसे कम प्राथमिकता वाले तत्व को बीएसटी के बाईं ओर यात्रियों के माध्यम से हटाया जाता है।
* यदि यह अवरोही क्रम की प्राथमिकता कतार है, तो उच्चतम प्राथमिकता वाले तत्व को BST के दाईं ओर ट्रैवर्सल के माध्यम से हटाया जाता है।
* यदि यह अवरोही क्रम की प्राथमिक पंक्ति है तो उच्चतम प्राथमिकता वाले तत्व को बीएसटी के दाईं ओर यात्रियों के माध्यम से हटाया जाता है।


== यह भी देखें ==
== यह भी देखें ==
{{Div col}}
* [[खोज पेड़]]
* ज्वाइन-आधारित ट्री एल्गोरिदम
* [[इष्टतम बाइनरी सर्च ट्री]]
* [[बाइनरी सर्च ट्री की ज्यामिति]]
* [[त्रिगुट खोज वृक्ष]]
{{colend}}
{{colend}}


Line 186: Line 209:


==बाहरी संबंध==
==बाहरी संबंध==
{{Commons category|Binary search trees}}
* {{anchor|Ben Pfaff Introduction}} Ben Pfaff: [http://ftp.gnu.org/gnu/avl/avl-2.0.3.pdf.gz ''An Introduction to Binary Search Trees and Balanced Trees''.] (PDF; 1675&nbsp;kB) 2004.
* {{anchor|Ben Pfaff Introduction}} Ben Pfaff: [http://ftp.gnu.org/gnu/avl/avl-2.0.3.pdf.gz ''An Introduction to Binary Search Trees and Balanced Trees''.] (PDF; 1675&nbsp;kB) 2004.
* [http://btv.melezinek.cz Binary Tree Visualizer] (JavaScript animation of various BT-based data structures)
* [http://btv.melezinek.cz Binary Tree Visualizer] (JavaScript animation of various BT-based data structures)


{{CS-Trees}}
{{DEFAULTSORT:Binary search tree}}
{{Data structures}}
 
{{DEFAULTSORT:Binary search tree}}[[Category: C++ कोड उदाहरण के साथ लेख]] [[Category: लेख उदाहरण के साथ पायथन (प्रोग्रामिंग भाषा) कोड]] [[Category: बाइनरी पेड़]] [[Category: पेड़ खोजें]]
 
 


[[Category: Machine Translated Page]]
[[Category:Articles with hatnote templates targeting a nonexistent page|Binary search tree]]
[[Category:Created On 24/02/2023]]
[[Category:C++ कोड उदाहरण के साथ लेख|Binary search tree]]
[[Category:CS1|Binary search tree]]
[[Category:CS1 русский-language sources (ru)|Binary search tree]]
[[Category:Created On 24/02/2023|Binary search tree]]
[[Category:Good articles|Binary search tree]]
[[Category:Lua-based templates|Binary search tree]]
[[Category:Machine Translated Page|Binary search tree]]
[[Category:Pages with reference errors|Binary search tree]]
[[Category:Pages with script errors|Binary search tree]]
[[Category:Templates Vigyan Ready|Binary search tree]]
[[Category:Templates that add a tracking category|Binary search tree]]
[[Category:Templates that generate short descriptions|Binary search tree]]
[[Category:Templates using TemplateData|Binary search tree]]
[[Category:पेड़ खोजें|Binary search tree]]
[[Category:बाइनरी पेड़|Binary search tree]]
[[Category:लेख उदाहरण के साथ पायथन (प्रोग्रामिंग भाषा) कोड|Binary search tree]]

Latest revision as of 09:43, 1 May 2023

Time complexity in big O notation
Algorithm Average Worst case
चित्र 1: आकार 9 और गहराई 3 का एक बाइनरी सर्च ट्री, जिसकी जड़ 8 है। पत्तियाँ नहीं खींची जाती हैं।

कम्प्यूटर विज्ञान एक बाइनरी सर्च ट्री है जिसे क्रम या चयनित बाइनरी ट्री भी कहा जाता है एक रूटेड बाइनरी ट्री डेटा संरचना है जिसकी आंतरिक कुंजी बाएं सर्च ट्री की सभी कुंजियों से अधिक होती हैं और उससे कम होती हैं बाइनरी सर्च ट्री पर एक संचालन की समय जटिलता सीधे ट्री की ऊंचाई के समानुपाती होती है।

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

सर्च ट्री का प्रदर्शन ट्री में नोड्स के सम्मिलन के क्रम पर निर्भर करता है क्योंकि मनमाना सम्मिलन अर्धपतन का कारण बन जाता है बाइनरी सर्च ट्री के कई रूपों को सबसे खराब स्थिति के प्रदर्शन की गारंटी के साथ बनाया जाता है क्योंकि इसमें मूल संचालन सम्मिलित हैं सबसे खराब स्थिति वाले बीएसटी एक अवर्गीकृत सारणी से बेहतर प्रदर्शन करते हैं जिनको रैखिक समय की आवश्यकता होती है।

बीएसटी के जटिलता विश्लेषण से पता चलता है कि औसतन डालने हटाने और खोजने में नोड्स के लिए n लगते हैं कि इसमें औसत स्थित और खोजें भी सम्मिलित हैं वे एक एकल लिंक की सूची सम्मिलन और विलोपन के साथ सर्च ट्री की ऊंचाई की असीमित वृद्धि को संबोधित करने के लिए बीएसटी के स्व-संतुलन बाइनरी सर्च ट्री संतुलन के रूपों को बाइनरी में शुरूआत करने की जटिलता को बाध्य करने के लिए पेश करते हैं इसमें एवीएल ट्री पहला स्व संतुलन बाइनरी सर्च ट्री था जिसका आविष्कार 1962 में एवीएल एड्स वेल्सकी और ईव्जेनी लैन्डिस द्वारा किया गया था।

बाइनरी सर्च ट्री का उपयोग अमूर्त डेटा जैसे सेट और प्राथमिकता पंक्ति को लागू करने के लिए किया जाता है और बाइनरी सर्च ट्री में इसका उपयोग किया जाता है।

इतिहास

बाइनरी सर्च ट्री प्रदर्शन स्वतंत्र रूप से कई शोधकर्ताओं द्वारा खोजा गया था जिसमें पी.एफ.विंडले एंड्रयू डोनाल्ड बूथ एंड्रयू कॉलिन थॉमस एन. हिब्बार्ड तथा [1][2] प्रदर्शन का श्रेय कॉनवे बर्नर्स-ली और डेविड व्हीलर कंप्यूटर वैज्ञानिक को दिया जाता है जिन्होंने 1960 में चुंबकीय टेप में विवरण किए गए डेटा को संग्रहित करने के लिए किया गया था।[3]

बाइनरी सर्च ट्री की जटिलताएं असीम रूप से बढ़ रही हैं यदि नोड्स को एक मनमाने क्रम में डालते हैं तो बाइनरी सर्च ट्री की ऊंचाई को सीमित करने के लिए स्व-संतुलन पेश किए गए थे [4] जैसे एवीएल ट्री ट्रीप और लाल काले ट्री [5] एवीएल का आविष्कार जॉर्जी एडेल्सन वेलेस्की और ईव्जेनी लैन्ड्स द्वारा 1962 में सूचना के कुशल संगठन के लिए किया गया था[6][7] यह आविष्कार किया जाने वाला पहला स्व-संतुलन बाइनरी सर्च ट्री था।[8]


सिंहावलोकन

बाइनरी सर्च ट्री एक पाठ्यक्रम है जिसमें नोड्स को एक क्रम में व्यवस्थित किया जाता है ये गैर-सख्त क्रम में रखे जाते हैं जिसमें किसी विशेष कुंजियों वाले बाइनरी सर्च ट्री से संग्रहित होते हैं तथा जो बाइनरी सर्च को संतुष्ट करते हैं।[9]: 298 [10]: 287 

खोज प्रारूप को छोटा करने में बाइनरी सर्च ट्री प्रभावशाली है जिसमें कार्यान्वित आदेश और पहचान करने की आवश्यकता नहीं होती है जबकि बीएसटी की खोज जटिलता के उस क्रम पर निर्भर करती है जिसमें नोड्स डाले और हटाए जाते हैं जिससे कि खराब स्थिति बाइनरी सर्च ट्री में क्रमिक संचालन अर्धपतन का कारण बन जाता है और संरचना की तरह एक एकल सूची बना सकता है इस प्रकार सूची के रूप में सबसे खराब स्थिति वाली जटिलता में संग्रहित किया जाता है।[11][9]: 299-302 

बाइनरी सर्च ट्री भी एक मूलभूत डेटा संरचना है जिसका उपयोग अमूर्त डेटा संरचनाओं जैसे सेट कंप्यूटर विज्ञान और साहचर्य सारणियों के निर्माण में किया जाता है।






संचालन

खोजना

एक विशिष्ट कुंजी के लिए बाइनरी सर्च ट्री को क्रमादेशित किया जाता है तथा इसमें पुनरावर्तन या पुनरावृत्ति की गणना की जाती है।

बाइनरी सर्च ट्री की डेटा संरचना में लकड़ी की जांच की खोज शुरू होती है अगर सर्च ट्री नल बिन्दु कुंजी रूट के बराबर है तो खोज सफल होगी और नोड वापस आ जाता है यदि कुंजी रूट से कम है तो खोज बाएँ ट्री की जाँच करके आगे बढ़ती है इसी तरह यदि कुंजी रूट से अधिक है तो खोज हो चुकी होती है यह प्रक्रिया तब तक दोहराई जाती है जब तक कि कुंजी मिल नहीं जाती या शेष सर्च ट्री नहीं मिल जाता यदि खोजी गई कुंजी नहीं मिलती तो कुंजी सर्च ट्री में नहीं होती है।[10]: 290–291 

पुनरावर्ती खोज

निम्नलिखित स्यूडोकोड पुनरावर्तन कंप्यूटर विज्ञान के माध्यम से बीटीएस खोज प्रक्रिया को लागू करता है।[10]

पुनरावृत्त खोज

खोज के पुनरावर्ती संस्करण को कुछ समय में नियंत्रित किया जा सकता है क्योंकि अधिकांश मशीनों पर पुनरावृत्त संस्करण कंप्यूटर प्रदर्शन में पाया जाता है।[10]: 291 

इसमें खोज के कुछ लसीका नोड होते हैं बीएसटी खोज की दौड़ कठिन होती है जबकि बीएसटी खोज की सबसे खराब स्थिति होती है तथा बीएसटी में नोड्स की कुल संख्या एन है क्योंकि एक असंतुलित बीएसटी एक सूची में खराब हो सकती है जबकि बीटीएस ऊँचाई-संतुलित सर्च ट्री है ।[10]

पूर्ववर्ती उत्तराधिकारी

कुछ कार्यों के लिए एक नोड दिया गया जिसके उत्तराधिकारी या पूर्ववर्ती का पता लगाना अत्यंत महत्वपूर्ण है जबकि बीएसटी की सभी कुंजियाँ अलग-अलग हैं तथा एक नोड के उत्तराधिकारी हैं बीएसटी में सबसे छोटी कुंजी वाला नोड एक्स है दूसरी ओर एक नोड के पूर्ववर्ती बीएसटी में सबसे बड़ी कुंजी से छोटा नोड एक्स है नोड के उत्तराधिकारी और पूर्ववर्ती को खोजने के लिए निम्नलिखित स्यूडोकोड की प्रयोग किया जाता है।

[12][13][10]

बीएसटी में एक नोड खोजने के लिए संचालन जिसकी कुंजी सीमा अधिकतम या न्यूनतम है यह कुछ कार्यों में महत्वपूर्ण हैं जैसे कि उत्तराधिकारी और नोड्स के पूर्ववर्ती का निर्धारण करना संचालन के लिए स्यूडोकोड महत्वपूर्ण हैं।[10]: 291–292 






प्रविष्टि

सम्मिलन और विलोपन संचालन बीएसटी प्रतिनिधित्व को गतिशील रूप से बदलने का कारण बनते हैं डेटा संरचना को इस तरह से संशोधित किया जाता है जिससे कि बीएसटी के गुण बने रहें बीएसटी में पत्ती के नोड्स के रूप में नए नोड डाले जाते हैं [10]जो सम्मिलित ऑपरेशन की प्रविष्टि करते हैं।[10]

हटाना

यह एक नोड का विलोपन है जो एक बाइनरी सर्च ट्री से बीएसटी की तीन स्थितियों का पालन करते हैं।[10]: 295 

  1. माना डी एक पत्ती है जो डी का मूल बिन्दु है डी सर्च ट्री से हटा दिया जाता है।
  2. अगर डी एक एकल विद्यार्थी है तो बच्चा बाएँ या दाएँ बच्चे के रूप में उन्नत करेगा डी माता-पिता की स्थिति के आधार पर कार्य करता है जैसे अंजीर में दिखाया गया है कि भाग ए और भाग बी और डी पेड़ से हटा दिया जाता है।
  3. अगर डी का उत्तराधिकारी एक बाएँ और दाएँ दोनों बच्चे हैं ई जिसके पास कोई बच्चा नहीं है तो इस स्थिति में वह क्या करेगा।
    1. अगर डी एस का दायां बच्चा ऊंचा हो जाता है तो ई के बॉंये बच्चे किस बिन्दु पर ले जाये जायेंगे।
      नोड '"`UNIQ--postMath-00000001-QINU`"' हटाने के लिए 2 बच्चे हैं

निम्नलिखित स्यूडोकोड बाइनरी सर्च ट्री में विलोपन ऑपरेशन को लागू करता है।[10]: 296-298  The following pseudocode implements the deletion operation in a binary search tree.[10]: 296-298 

1    BST-Delete(BST, D)
2      if D.left = NIL then
3        Shift-Nodes(BST, D, D.right)
4      else if D.right = NIL then
5        Shift-Nodes(BST, D, D.left)
6      else
7        E := Tree-Successor(D)
8        if E.parent ≠ D then
9          Shift-Nodes(BST, E, E.right)
10         E.right := D.right
11         E.right.parent := E
12       end if
13       Shift-Nodes(BST, D, E)
14       E.left := D.left
15       E.left.parent := E
16     end if
1    Shift-Nodes(BST, u, v)
2      if u.parent = NIL then
3        BST.root := v
4      else if u = u.parent.left then
5        u.parent.left := v
5      else
6        u.parent.right := v
7      end if
8      if v ≠ NIL then
9        v.parent := u.parent
10     end if

The procedure deals with the 3 special cases mentioned above. Lines 2-3 deal with case 1; lines 4-5 deal with case 2 and lines 6-16 for case 3. The helper function is used within the deletion algorithm for the purpose of replacing the node with in the binary search tree .[10]: 298  This procedure handles the deletion (and substitution) of from .






यात्रीगण

एक बीएसटी तीन बुनियादी प्रारूप के माध्यम से यात्रा हो सकती है यात्रा में आदेश उप आदेशिक यात्रा और पोस्ट आदेश यात्रायें भी सम्मिलित हैं।[10]

  • बाएं सर्च ट्री से नोड्स पहले देखे जाते हैं उसके बाद रूट देखे जाते हैं।
  • जड़ को पहले बहाया जाता है उसके बाद बाएँ और दाएँ सर्च ट्री को देखा जाता है।
  • बाएं सर्च ट्री से नोड्स पहले देखे जाते हैं।


संतुलित बाइनरी सर्च ट्री

पुनर्संतुलन के बिना बाइनरी सर्च ट्री में सम्मिलित या विलोपन अर्धपतन का कारण बन सकता है जिसके परिणामस्वरूप ऊँचाई होती है एक रेखीय खोज की तुलना में सर्च ट्री को संतुलित और ऊँचाई से घेरे रखना होता है बाइनरी प्रारूप जटिलता के लिए बाइनरी सर्च ट्री की ऊंचाई को बनाए रखने के लिए बनावट किए गए ट्री के अद्यतन संचालन के दौरान इसे स्व-संतुलन तंत्र द्वारा प्राप्त किया जा सकता है।[4][14]

ऊंचाई-संतुलित ट्री

एक सर्च ट्री ऊँचाई-संतुलित में होता है यदि बाइनरी सर्च ट्री की ऊँचाइयों को एक स्थिर कारक द्वारा संबंधित होने दिया जाता है। यह संपत्ति एवीएल ट्री द्वारा पेश की गई थी और लाल-काले ट्री द्वारा जारी रखी गई थी।[14]: 50–51 जड़ से संशोधित पत्ती तक पथ पर सभी की ऊंचाई को देखी जानी चाहिए और संभवतया ट्री में प्रत्येक डाल को हटाने के लिए सही किया जाना चाहिए।[14]: 52 






वजन-संतुलित ट्री

भार-संतुलित ट्री में संतुलित ट्री की कसौटी की पत्तियों की संख्या है बाएँ और दाएँ सर्च ट्री का वजन सबसे अधिक होता है [15][14]: 61  जबकि अंतर अनुपात से बंधा हुआ है अल्फा संतुलन की स्थिति के बाद नहीं रखा जा सकता सर्च ट्री संतुलन की स्थिति का एक पूरा परिवार होता है जहां प्रत्येक सर्च ट्री में कम से कम एक अंश होता है।[14]: 62 






प्रकार

कई स्व-संतुलित बाइनरी सर्च ट्री हैं जिनमें [16] [17] रेड-ब्लैक ट्री[18] भी होते हैं।


अनुप्रयोगों के उदाहरण

क्रमबद्ध करें

बाइनरी सर्च ट्री का उपयोग में ट्री का प्रारूप छोटा किया जाता है जहां सभी तत्वों को एक ही बार में डाला जाता है।


[19][20]


प्राथमिकता पंक्ति संचालन

बाइनरी सर्च ट्री का उपयोग प्राथमिक पंक्ति को लागू करने में किया जाता है कुंजी को प्राथमिकताओं के रूप में उपयोग करते हुए पंक्ति में नए तत्व में जोड़ना नियमित बीएसटी सम्मिलन ऑपरेशन का अनुसरण करता है लेकिन निष्कासन ऑपरेशन प्राथमिकता पंक्ति के प्रकार पर निर्भर करता है।[21]

  • यदि यह एक आरोही क्रम की प्राथमिक पंक्ति है तो सबसे कम प्राथमिकता वाले तत्व को बीएसटी के बाईं ओर यात्रियों के माध्यम से हटाया जाता है।
  • यदि यह अवरोही क्रम की प्राथमिक पंक्ति है तो उच्चतम प्राथमिकता वाले तत्व को बीएसटी के दाईं ओर यात्रियों के माध्यम से हटाया जाता है।

यह भी देखें

संदर्भ

  1. Culberson, J.; Munro, J. I. (1 January 1989). "लंबे समय तक अपडेट के तहत बाइनरी सर्च ट्री के व्यवहार की व्याख्या: एक मॉडल और सिमुलेशन". The Computer Journal. 32 (1): 68–69. doi:10.1093/comjnl/32.1.68.
  2. Culberson, J.; Munro, J. I. (28 July 1986). "सटीक फिट डोमेन बाइनरी सर्च ट्री में मानक विलोपन एल्गोरिदम का विश्लेषण". Algorithmica. Springer Publishing, University of Waterloo. 5 (1–4): 297. doi:10.1007/BF01840390. S2CID 971813.
  3. P. F. Windley (1 January 1960). "पेड़, वन और पुनर्व्यवस्था". The Computer Journal. 3 (2): 84. doi:10.1093/comjnl/3.2.84.
  4. 4.0 4.1 Knuth, Donald (1998). "Section 6.2.3: Balanced Trees". कंप्यूटर प्रोग्रामिंग की कला (PDF). Vol. 3 (2 ed.). Addison-Wesley. pp. 458–481. ISBN 978-0201896855. Archived (PDF) from the original on 2022-10-09.
  5. Paul E. Black, "red-black tree", in Dictionary of Algorithms and Data Structures [online], Paul E. Black, ed. 12 November 2019. (accessed May 19 2022) from: https://www.nist.gov/dads/HTML/redblack.html
  6. Myers, Andrew. "CS 312 Lecture: AVL Trees". Cornell University, Department of Computer Science. Archived from the original on 27 April 2021. Retrieved 19 May 2022.
  7. Adelson-Velsky, Georgy; Landis, Evgenii (1962). "सूचना के संगठन के लिए एक एल्गोरिथ्म". Proceedings of the USSR Academy of Sciences (in русский). 146: 263–266. English translation by Myron J. Ricci in Soviet Mathematics - Doklady, 3:1259–1263, 1962.
  8. Pitassi, Toniann (2015). "CSC263: Balanced BSTs, AVL tree" (PDF). University of Toronto, Department of Computer Science. p. 6. Archived (PDF) from the original on 14 February 2019. Retrieved 19 May 2022.
  9. 9.0 9.1 Thareja, Reema (13 October 2018). "Hashing and Collision". सी का उपयोग कर डेटा संरचनाएं (2 ed.). Oxford University Press. ISBN 9780198099307.
  10. 10.00 10.01 10.02 10.03 10.04 10.05 10.06 10.07 10.08 10.09 10.10 10.11 10.12 10.13 Cormen, Thomas H.; Leiserson, Charles E.; Rivest, Ronald L.; Stein, Clifford (2001). एल्गोरिदम का परिचय (2nd ed.). MIT Press. ISBN 0-262-03293-7.
  11. R. A. Frost; M. M. Peterson (1 February 1982). "A Short Note on Binary Search Trees". The Computer Journal. Oxford University Press. 25 (1): 158. doi:10.1093/comjnl/25.1.158.
  12. Junzhou Huang. "एल्गोरिदम का डिजाइन और विश्लेषण" (PDF). University of Texas at Arlington. p. 12. Archived (PDF) from the original on 13 April 2021. Retrieved 17 May 2021.
  13. Ray, Ray. "बाइनरी सर्च ट्री". Loyola Marymount University, Department of Computer Science. Retrieved 17 May 2022.
  14. 14.0 14.1 14.2 14.3 14.4 Brass, Peter (January 2011). उन्नत डेटा संरचना. Cambridge University Press. doi:10.1017/CBO9780511800191. ISBN 9780511800191.
  15. Blum, Norbert; Mehlhorn, Kurt (1978). "वजन-संतुलित पेड़ों में पुनर्संतुलन संचालन की औसत संख्या पर" (PDF). Theoretical Computer Science. 11 (3): 303–320. doi:10.1016/0304-3975(80)90018-3. Archived (PDF) from the original on 2022-10-09.
  16. Lehman, Tobin J.; Carey, Michael J. (25–28 August 1986). मेन मेमोरी डेटाबेस मैनेजमेंट सिस्टम्स के लिए इंडेक्स स्ट्रक्चर्स का अध्ययन. Twelfth International Conference on Very Large Databases (VLDB 1986). Kyoto. ISBN 0-934613-18-4.
  17. Aragon, Cecilia R.; Seidel, Raimund (1989), "Randomized Search Trees" (PDF), Proc. 30th Symp. Foundations of Computer Science (FOCS 1989), Washington, D.C.: IEEE Computer Society Press, pp. 540–545, doi:10.1109/SFCS.1989.63531, ISBN 0-8186-1982-1, archived (PDF) from the original on 2022-10-09
  18. Cormen, Thomas H.; Leiserson, Charles E.; Rivest, Ronald L.; Stein, Clifford (2001). "Red–Black Trees". Introduction to Algorithms (second ed.). MIT Press. pp. 273–301. ISBN 978-0-262-03293-3.
  19. Narayanan, Arvind (2019). "COS226: Binary search trees". Princeton University School of Engineering and Applied Science. Archived from the original on 22 March 2021. Retrieved 21 October 2021 – via cs.princeton.edu.
  20. Xiong, Li. "बाइनरी सर्च ट्री और क्विकसॉर्ट के बीच एक कनेक्शन". Oxford College of Emory University, The Department of Mathematics and Computer Science. Archived from the original on 26 February 2021. Retrieved 4 June 2022.
  21. Myers, Andrew. "CS 2112 Lecture and Recitation Notes: Priority Queues and Heaps". Cornell University, Department of Computer Science. Archived from the original on 21 October 2021. Retrieved 21 October 2021.


अग्रिम पठन


बाहरी संबंध