क्या किसी पेड़ को बिना किसी पुनरावृत्ति, ढेर या कतार के, और बस मुट्ठी भर बिंदुओं के साथ निकाला जा सकता है?

Question

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

तो, क्या यह संभव है, या असंभव है? क्यों या क्यों नहीं?

संपादित करें: कुछ स्पष्टीकरण जोड़ने के लिए, मैंने इसे एक बाइनरी ट्री पर लागू किया जिसमें तीन तत्व थे- प्रत्येक नोड पर संग्रहीत डेटा और दो बच्चों को इंगित करता है। मेरा समाधान केवल कुछ परिवर्तनों के साथ n-ary पेड़ों तक बढ़ाया जा सकता है।

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

Comments

आपको बाधाओं को निर्दिष्ट करने की आवश्यकता है। क्या मुझे पेड़ को म्यूट करने की अनुमति है? पेड़ का प्रतिनिधित्व कैसे किया जाता है? (उदाहरण के लिए, क्या प्रत्येक नोड का मूल अभिभावक के लिए सूचक है?) उत्तर विशिष्ट बाधाओं पर निर्भर करेगा; उन बाधाओं को निर्दिष्ट किए बिना, यह एक अच्छी तरह से उत्पन्न समस्या नहीं है।

— DW

मुझे लगता है कि वास्तव में व्यक्त करने वाले प्रोफेसर " अतिरिक्त स्थान" के साथ व्यक्त करना चाहते थे । लेकिन वैसे भी आपका समाधान क्या था? $O(1)$

— राफेल

Answer 1

इस क्षेत्र में बहुत सारे शोध गुंबद, कचरा संग्रह के संदर्भ में "सस्ते" ट्रैवर्सिंग पेड़ों और सामान्य सूची संरचनाओं की विधि से प्रेरित हैं।

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

जहां तक ​​मुझे पता है कि सामान्य फैशन में पॉइंटर्स (बाएं और दाएं पॉइंटर प्रति नोड) का उपयोग करके लागू किए गए द्विआधारी पेड़ को मॉरिस के लिए जिम्मेदार विधि में धागे की विधि का उपयोग करके पता लगाया जा सकता है । NIL-पॉइंटर्स अस्थायी रूप से रूट पर वापस रूट करने के लिए उपयोग किए जाते हैं। चतुर हिस्सा यह है कि ट्रैवर्सल के दौरान मूल किनारों को अस्थायी धागा-लिंक से अलग किया जा सकता है, जिस तरह से वे पेड़ में चक्र बनाते हैं)।

अच्छा हिस्सा: कोई अतिरिक्त डेटा संरचना नहीं। खराब हिस्सा: थोड़ा धोखा, ढेर चतुर तरीके से पेड़ के अंदर है। बहुत चालाक।

छिपे हुए स्टैक का एक प्रमाण पी। मैटेती और आर। मंगलमिरानी में दिखाया गया है: मॉरिस का ट्री ट्रैवर्सल एल्गोरिथ्म डीओआई: 10.1016 / 0167-6423 (88) 90063-9

जेएम मॉरिस: बस और सस्ते में बाइनरी पेड़ों की ट्रे Traनग। IPL 9 (1979) 197-200 DOI: 10.1016 / 0020-0190 (79) 90068-1

फिर लिंडस्ट्रॉम स्कैनिंग भी है । यह विधि प्रत्येक नोड (माता-पिता और दो बच्चों) में शामिल तीन बिंदुओं को "घुमाती" है। यदि आप किसी भी सभ्य पूर्व-आदेश या पोस्ट-ऑर्डर एल्गोरिदम का प्रदर्शन करना चाहते हैं, तो आपको प्रति नोड अतिरिक्त बिट्स की आवश्यकता होगी। यदि आप केवल सभी नोड्स (तीन बार जाना चाहते हैं, लेकिन आप कभी नहीं जानते हैं कि आप कौन सी यात्रा करते हैं) तो यह बिट्स के बिना किया जा सकता है।

जी। लिंडस्ट्रॉम: स्टैक्स या टैग बिट्स के बिना सूची संरचनाओं को स्कैन करना। आईपीएल 2 (1973) 47-51। डीओआई: 10.1016 / 0020-0190 (73) 90012-4

शायद सबसे सीधा तरीका रॉबसन द्वारा एक विधि है । यहां क्लासिक एल्गोरिथ्म के लिए आवश्यक स्टैक को पत्तियों के माध्यम से पिरोया गया है।

जेएम रॉबसन: सहायक स्टैक आईपीएल 1 (1973) 149-152 के बिना द्विआधारी पेड़ों को ट्रेस करने के लिए एक बेहतर एल्गोरिथ्म। 10,1016 / 0020-0190 (73) 90018-5

आईपीएल = सूचना प्रसंस्करण पत्र

Comments

मुझे यह समाधान भी पसंद है, हालांकि यह कुछ भी नहीं है कि मैं अपने कंप्यूटर विज्ञान कक्षाओं के पहले वर्ष के दौरान आया हूं। हाँ, शायद मेरे प्रोफेसर के नियमों के अनुसार धोखा दे।

— एनएल -

क्या आप रणनीतियों के लिए लिंक / संदर्भ दे सकते हैं?

— राफेल

उस विधि के साथ असली बुरा हिस्सा यह है कि आपके पास एक से अधिक ट्रैवर्सल किसी भी एक समय पर नहीं हो सकते हैं।

— गिल्स एसओ- बुराई को रोकना '

Answer 2

$v$

Comments

यह उस समाधान के समान है जो डेटा संरचना प्रोफेसर ने प्रस्तावित किया था जो इसे हल करने के लिए उपयोग की जाने वाली समस्या का प्रस्ताव देता है। असतत गणित के प्रोफेसर ने इस बात पर आपत्ति जताई कि "यह एक पेड़ के बजाय एक ग्राफ बन गया है" अगर माता-पिता के लिए संकेत हैं।

— एनएल -

@ नथनलाइडल: यह उस पेड़ की परिभाषा पर निर्भर करता है जिसका इस्तेमाल किया जाता है (जो आपने नहीं दिया)। "वास्तविक दुनिया" में, युवल के पेड़ का प्रतिनिधित्व उचित है, भले ही ग्राफ सिद्धांत उन चीजों को कहेगा जो वह परिभाषित करते हैं कि वे पेड़ नहीं हैं।

— राफेल

@ राफेल हां, और यह मूल प्रोफेसर की आवश्यकताओं को पूरा करता है, इसलिए यह मेरे लिए स्वीकार्य उत्तर है।

— एनएल -

Answer 3

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

Pseudocode:
root = pointer root 
depth = integer 0
finished = bool false
//If we n-ary tree also track how many children have been found 
//on the node with the most children for the purposes of this psuedocode 
//we'll assume a binary tree and insert a magic number of 2 so that we 
//can use bitwise operators instead of integer division 
while(!finished)
    ++depth
    treePosition = pointer root
    finished = true;
    for i := 0..2**depth
        for j := 0..depth
            if (i & j) //bitwise operator explained below
                // if right child doesn't exist break the loop
                treePosition = treePosition.rightChild
            else
                // if left child doesn't exist break the loop
                treePosition = treePosition.leftChild
        if j has any children
            finished = false
            do anything else you want when visiting the node

पहले कुछ स्तरों के लिए यह इस तरह दिखेगा, जैसा कि आप देख सकते हैं, स्यूडोकोड में बिटवाइज़ ऑपरेटर बस एक बाइनरी ट्री पर बाएं या दाएं मोड़ का फैसला करता है:

2**1       0               1
2**2   00      01      10      11
2**3 000 001 010 011 100 101 110 111

N-ary के लिए, आपको 0 और मैक्सचिल्ड्रेन के बीच कौन सा रास्ता लेना है, यह निर्धारित करने के लिए आप i% (maxChildren ** j) / j लेंगे।

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

Comments

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

— एनएल -

$O(1)$$O(\lg n)$$O(1)$$O(n)$$O(1)$। अतिरिक्त स्थान ") उदाहरण के लिए, क्या आप अगर करते हो depthकी चौड़ाई से अधिक है int?

— DW

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

— NL -

यह कहना एक बात है कि यह O (1) अतिरिक्त स्थान के बिना असाध्य है, यह एक और समस्या है कि पुनरावृत्ति, स्टैक, या कतार के बिना समस्या को असाध्य घोषित किया जाए। और वास्तव में, मेरे कोड को देखने के बाद असतत गणित के प्रोफेसर अभी भी इस बिंदु को स्वीकार नहीं करेंगे क्योंकि उन्होंने कहा था कि मैं पहली बार लूप के लिए "क्यू" ले रहा था। हार्ड-हेड के लिए यह कैसा है?

— एनएल -

idepthdepth$\Theta(n)$$\Theta(n)$i$O(1)$