जवाबों:
बाइनरी ट्री: ट्री जहां प्रत्येक नोड में दो पत्ते होते हैं
1
/ \
2 3
बाइनरी सर्च ट्री: खोज के लिए उपयोग किया जाता है । एक द्विआधारी पेड़ जहां बाएं बच्चे में केवल मूल नोड से कम मूल्यों वाले नोड होते हैं, और जहां सही बच्चे में केवल माता-पिता से अधिक या उसके बराबर मूल्यों वाले नोड होते हैं।
2
/ \
1 3
बाइनरी ट्री दो बच्चों (बाएं बच्चे और दाएं बच्चे) के साथ पेड़ का एक विशेष रूप है। यह केवल ट्री संरचना में डेटा का प्रतिनिधित्व है
बाइनरी सर्च ट्री (BST) एक विशेष प्रकार का बाइनरी ट्री है जो निम्न स्थिति का अनुसरण करता है:
एक बाइनरी ट्री नोड्स से बना है, जहां प्रत्येक नोड में एक "बाएं" पॉइंटर, एक "राइट" पॉइंटर और एक डेटा तत्व है। "रूट" पॉइंटर पेड़ में सबसे ऊपरी नोड की ओर इशारा करता है। बाएँ और दाएँ पॉइंटर्स पुनरावर्ती रूप से छोटे "सबट्रीज़" की ओर इंगित करते हैं। एक शून्य सूचक एक द्विआधारी वृक्ष का प्रतिनिधित्व करता है जिसमें कोई तत्व नहीं है - खाली पेड़। औपचारिक पुनरावर्ती परिभाषा है: एक द्विआधारी वृक्ष या तो खाली होता है (एक शून्य सूचक द्वारा दर्शाया जाता है), या एक एकल नोड से बना होता है, जहां बाईं और दाईं ओर संकेत (पुनरावर्ती परिभाषा आगे) एक द्विआधारी वृक्ष को इंगित करता है।
एक बाइनरी सर्च ट्री (BST) या "ऑर्डर किया हुआ बाइनरी ट्री" एक प्रकार का बाइनरी ट्री है जहाँ नोड्स को क्रम में व्यवस्थित किया जाता है: प्रत्येक नोड के लिए, इसके बाएं सबट्री में सभी तत्व नोड (<) से कम होते हैं, और सभी तत्व इसके दाईं ओर सबट्री नोड (>) से अधिक है।
5
/ \
3 6
/ \ \
1 4 9
ऊपर दिखाया गया पेड़ एक बाइनरी सर्च ट्री है - "रूट" नोड एक 5 है, और इसके बाएं सबट्री नोड्स (1, 3, 4) <5 हैं, और इसके राइट सबट्री नोड्स (6, 9)> 5 हैं। पुनरावर्ती रूप से, प्रत्येक उपप्रकार को भी द्विआधारी खोज ट्री बाधा का पालन करना चाहिए: 1 (1, 3, 4) सबट्री में, 3 मूल है, 1 <3 और 4> 3 है।
समस्याओं में सटीक शब्दों के लिए देखें - "बाइनरी ट्री" एक "बाइनरी ट्री" से अलग है।
जैसा कि ऊपर दिए गए सभी लोगों ने बाइनरी ट्री और बाइनरी सर्च ट्री के बीच अंतर के बारे में बताया है, मैं सिर्फ यह परीक्षण कर रहा हूं कि क्या दिया गया बाइनरी ट्री बाइनरी सर्च ट्री है या नहीं।
boolean b = new Sample().isBinarySearchTree(n1, Integer.MIN_VALUE, Integer.MAX_VALUE);
.......
.......
.......
public boolean isBinarySearchTree(TreeNode node, int min, int max)
{
if(node == null)
{
return true;
}
boolean left = isBinarySearchTree(node.getLeft(), min, node.getValue());
boolean right = isBinarySearchTree(node.getRight(), node.getValue(), max);
return left && right && (node.getValue()<max) && (node.getValue()>=min);
}
आशा है इससे आपकी मदद होगी। क्षमा करें, अगर मैं इस विषय से विचलित हो रहा हूँ जैसा कि मैंने महसूस किया कि यह यहाँ उल्लेख के लायक है।
बाइनरी ट्री एक के लिए खड़ा है डेटा संरचना जो से बना है नोड्स कर सकते हैं कि केवल है दो बच्चों संदर्भ।
दूसरी ओर बाइनरी सर्च ट्री ( BST ), बाइनरी ट्री डेटा संरचना का एक विशेष रूप है, जहां प्रत्येक नोड का एक तुलनीय मूल्य होता है, और छोटे मूल्यवान बच्चे बायें से जुड़े होते हैं और दाएं से जुड़े बड़े मूल्यवान बच्चे होते हैं।
इस प्रकार, सभी BST के हैं बाइनरी ट्री लेकिन केवल कुछ बाइनरी ट्री रों भी हो सकता है ' BST । सूचित करें कि BST बाइनरी ट्री का सबसेट है ।
तो, बाइनरी ट्री बाइनरी सर्च ट्री की तुलना में सामान्य डेटा-संरचना का अधिक है । और आपको यह भी सूचित करना होगा कि बाइनरी सर्च ट्री एक सॉर्टेड ट्री है, जबकि जेनेरिक बाइनरी ट्री के लिए नियमों का ऐसा कोई सेट नहीं है ।
एक Binary Tree
जो है नहीं एक BST
;
5
/ \
/ \
9 2
/ \ / \
15 17 19 21
एक द्विआधारी खोज वृक्ष जो भी एक है बाइनरी ट्री ;
50
/ \
/ \
25 75
/ \ / \
20 30 70 80
यह भी सूचित करें कि BST में किसी भी मूल नोड के लिए ;
सभी बाएँ नोड्स का मूल नोड के मान से छोटा मान है। ऊपरी उदाहरण में, मानों के साथ नोड्स {20, 25, 30} जो सभी 50 के बाएं ( बाएं वंशज ) पर स्थित हैं, 50 से छोटे हैं।
सभी सही नोड्स का मूल नोड के मान से अधिक मूल्य है। ऊपरी उदाहरण में, मानों के साथ नोड्स {70, 75, 80} जो सभी 50 के दाईं ओर ( दाएं वंशज ) पर स्थित हैं, 50 से अधिक हैं।
बाइनरी ट्री नोड के लिए ऐसा कोई नियम नहीं है । बाइनरी ट्री नोड के लिए एकमात्र नियम दो बच्चे हैं, इसलिए यह स्वयं ही बताता है कि बाइनरी क्यों कहा जाता है ।
एक बाइनरी सर्च ट्री एक विशेष प्रकार का बाइनरी ट्री है जो निम्नलिखित संपत्ति प्रदर्शित करता है: किसी भी नोड n के लिए, n के बाएं सबट्री में प्रत्येक वंशज नोड का मान n के मूल्य से कम है, और प्रत्येक अवरोही नोड का मूल्य सही उप-वर्ग में है n के मान से अधिक है।
बाइनरी ट्री
बाइनरी ट्री कुछ भी हो सकता है जिसमें 2 बच्चे और 1 माता-पिता हैं। इसे लिंक की गई सूची या सरणी के रूप में, या आपके कस्टम एपीआई के साथ लागू किया जा सकता है। एक बार जब आप इसमें और विशिष्ट नियम जोड़ना शुरू करते हैं, तो यह अधिक विशिष्ट वृक्ष बन जाता है । सबसे आम ज्ञात कार्यान्वयन यह है कि, बाईं ओर छोटे नोड्स और दाईं ओर बड़े वाले जोड़ें।
उदाहरण के लिए, आकार 9 और ऊंचाई 3 का एक लेबल बाइनरी ट्री, रूट नोड के साथ जिसका मूल्य 2. वृक्ष असंतुलित है और छँटा नहीं गया है । https://en.wikipedia.org/wiki/Binary_tree
उदाहरण के लिए, बाईं ओर के पेड़ में, A के 6 बच्चे हैं {B, C, D, E, F, G}। इसे दाईं ओर बाइनरी ट्री में बदला जा सकता है।
द्विआधारी खोज
बाइनरी सर्च तकनीक / एल्गोरिदम है जो नोड चेन पर विशिष्ट आइटम खोजने के लिए उपयोग किया जाता है। बाइनरी खोज क्रमबद्ध सरणियों पर काम करती है ।
बाइनरी खोज लक्ष्य मान की तुलना सरणी के मध्य तत्व से करती है; यदि वे असमान हैं, तो जो लक्ष्य झूठ नहीं बोल सकता है वह आधा समाप्त हो गया है और शेष आधे पर खोज जारी है जब तक कि यह सफल न हो या शेष आधा खाली न हो। https://en.wikipedia.org/wiki/Binary_search_algorithm
एक पेड़ जो बाइनरी खोज का प्रतिनिधित्व करता है । यहां खोजे जा रहे ऐरे [२०, ३०, ४०, ५०, ९ ०, १००] और लक्ष्य मूल्य ४० है।
बाइनरी सर्च ट्री
यह बाइनरी ट्री के कार्यान्वयन में से एक है। यह खोज के लिए विशेष है ।
बाइनरी सर्च ट्री और बी-ट्री डेटा संरचनाएं बाइनरी सर्च पर आधारित हैं ।
बाइनरी सर्च ट्री (BST), जिसे कभी-कभी ऑर्डर किए गए या सॉर्ट किए गए बाइनरी ट्री कहा जाता है, एक विशेष प्रकार के कंटेनर होते हैं : डेटा संरचनाएं जो मेमोरी में "आइटम" (जैसे संख्या, नाम आदि) को स्टोर करती हैं। https://en.wikipedia.org/wiki/Binary_search_tree
जड़ पर 8 के साथ आकार 9 और गहराई 3 का एक द्विआधारी खोज पेड़। पत्तियाँ खींची नहीं जातीं।
और अंत में लागू प्रसिद्ध डेटा-संरचनाओं और एल्गोरिदम के प्रदर्शन की तुलना के लिए महान स्कीमा:
एल्गोरिदम से ली गई छवि (4 वां संस्करण)
किसी बाइनरी ट्री की जांच करने के लिए बाइनरी ट्री यहां बाइनरी सर्च ट्री है और एक वैकल्पिक दृष्टिकोण है।
Traverse ट्री में Inorder फैशन (यानी वाम बाल -> जनक -> सही बच्चा), स्टोर चल नोड डाटा एक अस्थायी चर में कहते हैं की सुविधा देता है अस्थायी , बस में भंडारण से पहले अस्थायी , चेक wheather वर्तमान नोड के डेटा उच्च उसके बाद पिछले एक या नहीं है । तो बस इसे बाहर तोड़ , ट्री बाइनरी सर्च ट्री नहीं है और दूसरे छोर को पार करना है।
नीचे जावा के साथ एक उदाहरण दिया गया है:
public static boolean isBinarySearchTree(Tree root)
{
if(root==null)
return false;
isBinarySearchTree(root.left);
if(tree.data<temp)
return false;
else
temp=tree.data;
isBinarySearchTree(root.right);
return true;
}
बाहर अस्थायी चर बनाए रखें
एक बाइनरी सर्च ट्री में, सभी नोड्स को एक विशिष्ट क्रम में व्यवस्थित किया जाता है - रूट नोड के बाईं ओर नोड्स का इसकी जड़ की तुलना में एक छोटा मूल्य होता है, और नोड के दाईं ओर के सभी नोड्स में मान के मान से अधिक होता है जड़।