कैसे BST की संपत्ति को बनाए रखने के दो द्विआधारी खोज के पेड़ विलय करने के लिए?
हम एक पेड़ से प्रत्येक तत्व लेने के लिए और अन्य में डालने का फैसला करते हैं, इस विधि की जटिलता होगा O(n1 * log(n2)), जहां n1पेड़ के नोड्स (मान लीजिए की संख्या है T1) है, जो हम splitted है, और n2के नोड्स की संख्या है अन्य पेड़ (माना T2)। इस ऑपरेशन के बाद केवल एक BST है n1 + n2नोड्स।
मेरे सवाल यह है: हम किसी भी तुलना में हे बेहतर (n1 * लॉग (एन 2)) कर सकता है?
क्या, हल कर सूचियों में दोनों पेड़ सपाट सूचियों विलय और फिर एक नई पेड़ बनाने के बारे में?
IIRC, कि हे (n1 + n2) है।
एक छोटे से अधिक विवरण के साथ Naaff के जवाब:
हे में ओ (n1 + n2) परिणाम में से तीन कदम (n1 + n2)
n1 और परिमाण के एक ही आदेश के n2 के लिए, कि हे की तुलना में बेहतर है (n1 * लॉग (एन 2))
जोनाथन,
छँटाई के बाद, हम लंबाई n1 + n2 की एक सूची है। इसे से बाहर एक द्विआधारी पेड़ का निर्माण लॉग इन करें (n1 + n2) में समय लगेगा। इस मर्ज प्रकार के रूप में एक ही है, केवल कि प्रत्येक पुनरावर्ती कदम पर हम अभ्यस्त एक ओ (n1 + n2) अवधि है के रूप में हम मर्ज तरह एल्गोरिथ्म में है। तो समय जटिलता लॉग (n1 + n2) है।
अब पूरी समस्या की जटिलता ओ (n1 + n2) है।
इसके अलावा मैं कहूंगा कि इस दृष्टिकोण अच्छा है अगर दो सूचियों तुलनीय आकार के होते हैं। आकार तो तुलनीय नहीं हैं, तो यह एक बड़ा पेड़ में छोटे पेड़ के हर नोड डालने के लिए सबसे अच्छा है। यह ओ (n1 * लॉग (एन 2)) समय लगेगा। उदाहरण के लिए हम दो पेड़ आकार 1024 का आकार 10 में से एक और एक अन्य है, तो यहाँ n1 + n2 = 1034 जहां n1log (एन 2) = 10 * 10 = 100 तो दृष्टिकोण दो पेड़ों के आकार पर निर्भर रहना पड़ता है।
ओ (n1 * लॉग (एन 2)) औसत स्थिति है भले ही हम 2 मर्ज एक BST में किसी भी अवर्गीकृत सूची है। हम तथ्य यह है कि सूची क्रमबद्ध सूची या एक BST है का उपयोग नहीं कर रहे हैं।
मेरे हिसाब से देता है एक BST मान n1 तत्व है और अन्य n2 तत्व है। अब किसी क्रमित सरणी ओ (n1) में सूची एल 1 में एक BST परिवर्तित।
मर्ज कर दिया गया BST (BST, सरणी)
अगर (Array.size == 0) वापसी BST अगर (Array.size == 1) BST में तत्व सम्मिलित। BST वापसी;
सरणी जिसका बाईं तत्व <BST.rootnode और सही तत्व> = BST.rootnode कहना सूचकांक में सूचकांक का पता लगाएं। अगर (BST.rootNode.leftNode == नल) // यानी कोई बाईं नोड किसी और {0 के सूचकांक से सभी सरणी डालने में BST के लिए छोड़ दिया और} {विलय BST (BST.leftNode, सरणी {0 सूचकांक})}
अगर (BST.rootNode.rightNode == नल) // यानी कोई सही नोड else {BST के अधिकार में Array.size के सूचकांक से सभी सरणी सम्मिलित} {विलय BST (BST.rightNode, सरणी {सूचकांक Array.size करने} )}
BST लौट आते हैं।
इस एल्गोरिथ्म हर बार जब हम सरणी और subproblem संभाल करने BST विभाजन कर रहे हैं के रूप में << ओ (n1 * लॉग (एन 2)) की तुलना में समय लगेगा।
विचार ट्रेवर्सल inorder पुनरावृत्ति का प्रयोग है। हम दो BSTs के लिए दो सहायक के ढेर का उपयोग करें। जब से हम, क्रमबद्ध रूप में तत्वों मुद्रित करने के लिए जब भी हम पेड़ों में से किसी से एक छोटे तत्व मिल की जरूरत है, हम इसे प्रिंट। तत्व अधिक होता है, तो हम इसे वापस धक्का अगले चरण के लिए ढेर।
