C ++ STL कोई "ट्री" कंटेनर क्यों नहीं प्रदान करता है?

Question

C ++ STL कोई "ट्री" कंटेनर क्यों नहीं प्रदान करता है, और इसके बजाय सबसे अच्छी बात क्या है?

मैं एक पेड़ की एक पदानुक्रम को एक पेड़ के रूप में संग्रहीत करना चाहता हूं, बजाय एक पेड़ को प्रदर्शन बढ़ाने के रूप में उपयोग करना ...

Comments

मुझे एक पदानुक्रम का प्रतिनिधित्व संग्रहीत करने के लिए एक पेड़ की आवश्यकता है।

— रोडी

मैं उस आदमी के साथ हूं जिसने नीचे "सही" जवाब दिया, जो लगता है; "पेड़ बेकार हैं"। पेड़ों के अस्पष्ट उपयोग के लिए महत्वपूर्ण हैं।

— जो सोल-लाने वाला

मुझे लगता है कि कारण तुच्छ है - किसी ने भी इसे मानक पुस्तकालय में अभी तक लागू नहीं किया है। यह मानक पुस्तकालय जैसा है std::unordered_mapऔर std::unordered_setहाल तक तक नहीं था । और इससे पहले मानक पुस्तकालय में एसटीएल कंटेनर बिल्कुल नहीं थे।

— doc

मेरे विचार (हालांकि प्रासंगिक मानक को कभी नहीं पढ़ा है, इसलिए यह एक टिप्पणी नहीं है एक जवाब है) कि एसटीएल विशिष्ट डेटा संरचनाओं के बारे में परवाह नहीं करता है, यह जटिलता के बारे में विशिष्टताओं और संचालन के बारे में परवाह करता है। इसलिए उपयोग की जाने वाली अंतर्निहित संरचना कार्यान्वयन और / या लक्ष्य आर्किटेक्चर के बीच भिन्न हो सकती है, बशर्ते कि यह विनिर्देशों को संतुष्ट करता है। मुझे पूरा यकीन है std::mapऔर std::setवहां हर कार्यान्वयन में एक पेड़ का उपयोग करेगा, लेकिन अगर कुछ गैर-पेड़ संरचना भी विनिर्देशों को पूरा करती है तो उन्हें नहीं करना चाहिए।

— मार्क के कोवन

Answer 1

एक पेड़ का उपयोग करने के लिए दो कारण हो सकते हैं:

आप एक पेड़ जैसी संरचना का उपयोग करके समस्या को प्रतिबिंबित करना चाहते हैं:
इसके लिए हमारे पास ग्राफ लाइब्रेरी को बढ़ावा देना है

या आप एक कंटेनर चाहते हैं जिसमें पेड़ की तरह पहुंच विशेषताएं हैं इसके लिए हमारे पास है

• std::map( std::multimap)
• std::set( std::multiset)

मूल रूप से इन दो कंटेनरों की विशेषताएं ऐसी हैं कि उन्हें व्यावहारिक रूप से पेड़ों का उपयोग करके लागू किया जाना है (हालांकि यह वास्तव में आवश्यकता नहीं है)।

इस प्रश्न को भी देखें: C ट्री इम्प्लीमेंटेशन

Comments

एक पेड़ का उपयोग करने के कई, कई कारण हैं, भले ही ये सबसे आम हों। सबसे आम! सभी के बराबर।

— जो सोल-लाने वाला

एक पेड़ को चाहने का तीसरा बड़ा कारण हमेशा की तरह तेज़ प्रविष्टि / निष्कासन के साथ छांटना है, लेकिन इसके लिए std: multiset है।

— VoidStar

@ दुर्गा: जब आप मानचित्र को एक सॉर्ट किए गए कंटेनर के रूप में उपयोग कर रहे हों, तो यह निश्चित नहीं है कि गहराई कितनी प्रासंगिक है। मानचित्र गारंटी लॉग (n) प्रविष्टि / विलोपन / लुकअप (और सॉर्ट किए गए तत्वों में युक्त)। यह सभी नक्शे के लिए उपयोग किया जाता है और लाल (काले) पेड़ के रूप में लागू किया जाता है। एक लाल / काला पेड़ सुनिश्चित करता है कि पेड़ संतुलित है। तो पेड़ की गहराई सीधे पेड़ में तत्वों की संख्या से संबंधित है।

— मार्टिन यॉर्क

मैं इस जवाब से असहमत हूं, 2008 और अब दोनों में। मानक लाइब्रेरी में "बढ़ावा" नहीं है, और बढ़ावा देने में कुछ की उपलब्धता मानक में इसे नहीं अपनाने का कारण (और नहीं) होना चाहिए। इसके अतिरिक्त, बीजीएल सामान्य है और इसमें विशेष रूप से स्वतंत्र पेड़ वर्गों का विलय करने के लिए पर्याप्त है। इसके अलावा, तथ्य यह है कि एसटीडी :: नक्शा और एसटीडी :: सेट के लिए एक पेड़ की आवश्यकता होती है, आईएमओ, stl::red_black_treeआदि होने के लिए एक और तर्क अंत में, std::mapऔर std::setपेड़ संतुलित हैं, एक std::treeनहीं हो सकता है।

— einpoklum

@einpoklum: "किसी चीज की उपलब्धता को मानक में नहीं अपनाने का कारण नहीं होना चाहिए" - बढ़ावा देने के उद्देश्यों में से एक यह है कि मानक में शामिल करने से पहले उपयोगी पुस्तकालयों के लिए एक साबित जमीन के रूप में कार्य करना है, मैं केवल यही कर सकता हूं। "बिल्कुल!"

— मार्टिन बोनर

Answer 2

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

कुछ मुद्दों पर विचार करने के लिए:

• क्या नोड के लिए बच्चों की संख्या निश्चित या परिवर्तनशील है?
• प्रति नोड कितना ओवरहेड? - यानी, क्या आपको पेरेंट पॉइंटर्स, सिबलिंग पॉइंटर्स आदि की जरूरत है।
• क्या एल्गोरिदम प्रदान करने के लिए? - विभिन्न पुनरावृत्तियों, खोज एल्गोरिदम, आदि।

अंत में, यह समस्या समाप्त हो रही है कि एक ट्री कंटेनर जो सभी के लिए पर्याप्त उपयोगी होगा, इसका उपयोग करने वाले अधिकांश लोगों को संतुष्ट करने के लिए बहुत भारी होगा। यदि आप कुछ शक्तिशाली की तलाश कर रहे हैं, तो बूस्ट ग्राफ लाइब्रेरी अनिवार्य रूप से एक सुपरसेट है जो एक ट्री लाइब्रेरी के लिए इस्तेमाल किया जा सकता है।

यहाँ कुछ अन्य जेनेरिक पेड़ कार्यान्वयन हैं:

• कैस्पर पीटर्स का पेड़
• एडोब का जंगल
• कोर :: पेड़

Comments

"... हर किसी को संतुष्ट करने का कोई अच्छा तरीका नहीं है ..." सिवाय इसके कि चूंकि stl :: map, stl :: multimap, और stl :: set, stl के rb_tree पर आधारित हैं, यह सिर्फ उन कई मामलों को संतुष्ट करना चाहिए जैसे उन बुनियादी प्रकारों को करते हैं। ।

— कैटस्कूल

एक नोड के बच्चों को पुनः प्राप्त करने का कोई तरीका नहीं है, यह ध्यान में रखते हुए std::map, मैं उन पेड़ों के कंटेनरों को कॉल नहीं करूंगा। वे साहचर्य कंटेनर हैं जिन्हें आमतौर पर पेड़ों के रूप में लागू किया जाता है। बड़ा अंतर।

— मूविंग डक

मैं मूइंग डक से सहमत हूं, आप एक std :: मानचित्र पर पहली चौड़ाई खोज कैसे लागू करेंगे? यह बहुत महंगा होने जा रहा है

— मार्को ए।

मैंने कैस्पर पीटर्स के पेड़ का उपयोग करना शुरू कर दिया था। हालांकि, GPLv3, या किसी अन्य GPL संस्करण के लिए लाइसेंसिंग की समीक्षा करने के बाद, यह हमारे वाणिज्यिक सॉफ़्टवेयर को दूषित कर देगा। यदि आप वाणिज्यिक प्रयोजनों के लिए एक संरचना की जरूरत है तो मैं @hplbsh द्वारा टिप्पणी में प्रदान की गई treetree को देखने की सलाह दूंगा।

— जेक़ा

पेड़ों पर विभिन्न प्रकार की विशिष्ट आवश्यकताएं विभिन्न प्रकार के पेड़ों को रखने का एक तर्क है, बिल्कुल भी नहीं।

— आंद्रे

Answer 3

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

Comments

मुझे नहीं लगता कि वह कंटेनर कार्यान्वयन के बारे में बात कर रहा है, वह खुद एक वास्तविक ट्री कंटेनर के बारे में बात कर रहा है।

— मूविंग डक

@MooingDuck मुझे लगता है कि विल्हेमटेल का मतलब क्या है कि C ++ मानक पुस्तकालय उनके अंतर्निहित डेटा संरचना के आधार पर कंटेनरों को परिभाषित नहीं करता है; यह केवल उनके इंटरफ़ेस और अस्मितावादी प्रदर्शन जैसी नमूदार विशेषताओं द्वारा कंटेनरों को परिभाषित करता है। जब आप इसके बारे में सोचते हैं, तो एक पेड़ वास्तव में एक कंटेनर नहीं है (जैसा कि हम उन्हें जानते हैं)। वे आगे भी सीधे नहीं हैं end()और begin()जिसके साथ आप सभी तत्वों के माध्यम से पुनरावृति कर सकते हैं, आदि

— जॉर्डन मेलो

@ जोर्डनमेलो: सभी बिंदुओं पर बकवास। यह एक ऐसी चीज है जिसमें वस्तुएं होती हैं। इसे शुरू करने के लिए () और अंत () और द्विदिश चलने वाले पुनरावृत्तियों के साथ इसे डिज़ाइन करना बहुत तुच्छ है। प्रत्येक कंटेनर में अलग-अलग विशेषताएं हैं। यह उपयोगी होगा यदि कोई इसके अतिरिक्त पेड़ की विशेषताएं हो सकता है। बहुत आसान होना चाहिए।

— मूविंग डक

इस प्रकार एक कंटेनर होना चाहता है जो बच्चे और माता-पिता के नोड्स के लिए तेजी से लुकअप प्रदान करता है, और उचित मेमोरी आवश्यकताओं।

— doc

@ जोर्डनमेलो: उस नजरिए से भी, क्वीन्स, स्टाॅक या प्रायोरिटी कतारों जैसे एडाप्टर्स एसटीएल (वे भी नहीं है begin()और end()) के हैं। और याद रखें कि प्राथमिकता कतार आमतौर पर एक ढेर है, जो कम से कम सिद्धांत में एक पेड़ है (भले ही वास्तविक कार्यान्वयन हो)। इसलिए भले ही आपने कुछ अलग अंतर्निहित डेटा संरचना का उपयोग करके एक एडेप्टर के रूप में एक पेड़ को लागू किया हो, यह एसटीएल में शामिल होने के लिए योग्य होगा।

— andreee

Answer 4

"मैं एक पेड़ के रूप में वस्तुओं के पदानुक्रम को संग्रहीत करना चाहता हूं"

C ++ 11 आया है और चला गया है और उन्हें अभी भी एक प्रदान करने की आवश्यकता नहीं दिख रही है std::tree, हालाँकि विचार आया ( यहाँ देखें )। हो सकता है कि उन्होंने जो कारण नहीं जोड़ा है, वह यह है कि मौजूदा कंटेनरों के ऊपर अपना खुद का निर्माण करना बहुत आसान है। उदाहरण के लिए...

template< typename T >
struct tree_node
   {
   T t;
   std::vector<tree_node> children;
   };

एक साधारण ट्रैवर्सल पुनरावृत्ति का उपयोग करेगा ...

template< typename T >
void tree_node<T>::walk_depth_first() const
   {
   cout<<t;
   for ( auto & n: children ) n.walk_depth_first();
   }

यदि आप एक पदानुक्रम बनाए रखना चाहते हैं और आप चाहते हैं कि यह एसटीएल एल्गोरिदम के साथ काम करे , तो चीजें जटिल हो सकती हैं। आप अपने स्वयं के पुनरावृत्तियों का निर्माण कर सकते हैं और कुछ संगतता प्राप्त कर सकते हैं, हालांकि कई एल्गोरिदम बस एक पदानुक्रम के लिए कोई मतलब नहीं रखते हैं (कुछ भी जो सीमा के क्रम को बदलता है, उदाहरण के लिए)। यहां तक ​​कि एक पदानुक्रम के भीतर एक सीमा को परिभाषित करना एक गन्दा व्यवसाय हो सकता है।

Comments

यदि परियोजना ट्री_नोड के बच्चों के लिए छाँटने की अनुमति दे सकती है, तो std :: वेक्टर <> के स्थान पर एक std :: set <> का उपयोग करके और फिर एक ऑपरेटर <() को पेड़_node ऑब्जेक्ट में जोड़ने से बहुत सुधार होगा एक 'टी' जैसी वस्तु का 'खोज' प्रदर्शन।

— J Jorgenson

यह पता चला है कि वे आलसी थे और वास्तव में आपका पहला उदाहरण अपरिभाषित व्यवहार था।

— user541686

@ मेहरदाद: मैंने आखिरकार यहां आपकी टिप्पणी के पीछे विस्तार से पूछने का फैसला किया ।

— नोबार

many of the algorithms simply don't make any sense for a hierarchy। व्याख्या का विषय। स्टैकओवरफ़्लो उपयोगकर्ताओं की एक संरचना की कल्पना करें और हर साल आप कम प्रतिष्ठा वाले लोगों को बॉस की उच्च मात्रा के साथ प्रतिष्ठा के बिंदु चाहते हैं। इस प्रकार बीएफएस पुनरावृत्ति और उचित तुलना प्रदान करते हुए, हर साल आप बस चलाते हैं std::sort(tree.begin(), tree.end())।

— doc

इसी टोकन के द्वारा, आप ऊपर दिए गए उदाहरण के vectorसाथ प्रतिस्थापित करके आसानी से एक संबंधित वृक्ष (बिना चाबी के मान के रिकॉर्ड, उदाहरण के लिए JSON का मॉडल बना सकते हैं) map। JSON जैसी संरचना के पूर्ण समर्थन के लिए, आप variantनोड्स को परिभाषित करने के लिए उपयोग कर सकते हैं ।

— नोबार

Answer 5

यदि आप आरबी-ट्री कार्यान्वयन की तलाश कर रहे हैं, तो stl_tree.h आपके लिए भी उपयुक्त हो सकता है।

Comments

वास्तव में यह एकमात्र प्रतिक्रिया है जो वास्तव में मूल प्रश्न का उत्तर देती है।

— कैट्सकुल

यह मानते हुए कि वह "हेयार्की" चाहता है, यह मानना ​​सुरक्षित है कि "संतुलन" के साथ कुछ भी गलत उत्तर है।

— मूविंग डक

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

— दान

@ डान: इसे कॉपी करना सीधे इसका उपयोग करने से नहीं बनता है।

— ईनपोकलुम

Answer 6

एसटीडी :: नक्शा एक लाल काले पेड़ पर आधारित है । आप अपने खुद के प्रकार के पेड़ों को लागू करने में मदद करने के लिए अन्य कंटेनरों का भी उपयोग कर सकते हैं ।

Comments

यह आमतौर पर लाल-काले पेड़ों (ऐसा करने की आवश्यकता नहीं है) का उपयोग करता है।

— मार्टिन यॉर्क

जीसीसी नक्शे को लागू करने के लिए एक पेड़ का उपयोग करता है। कोई भी अपने कुलपति को देखना चाहता है जिसमें निर्देशिका का उपयोग होता है यह देखने के लिए कि Microsoft क्या उपयोग करता है?

— जे जे

// लाल-काला पेड़ वर्ग, जिसे एसटीएल // सहयोगी कंटेनरों (सेट, मल्टीसेट, मैप और मल्टीमप) को लागू करने में उपयोग के लिए डिज़ाइन किया गया है। पकड़ा कि मेरी stl_tree.h फ़ाइल से।

— जेजे

@JJ कम से कम स्टूडियो 2010 में, यह एक आंतरिक ordered red-black tree of {key, mapped} values, unique keysवर्ग का उपयोग करता है , जिसमें परिभाषित किया गया है <xtree>। इस समय अधिक आधुनिक संस्करण तक पहुँच नहीं है।

— जस्टिन टाइम -

Answer 7

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

सामान्य तौर पर, यदि कोई मूल लाइब्रेरी कार्यक्षमता है जिसे आप चाहते हैं, तो वह stl में नहीं है, तो फिक्स BOOST को देखना है ।

अन्यथा, वहाँ एक है गुच्छा के पुस्तकालयों बाहर वहाँ अपने पेड़ की जरूरतों के आधार पर,।

Answer 8

सभी एसटीएल कंटेनर बाहरी रूप से एक पुनरावृत्ति तंत्र के साथ "अनुक्रम" के रूप में दर्शाए जाते हैं। पेड़ इस मुहावरे का पालन नहीं करते हैं।

Comments

एक ट्री डेटा संरचना पुनरावृत्तियों के माध्यम से प्रीऑर्डर, इनवर्टर या पोस्टऑर्डर ट्रैवर्सल प्रदान कर सकती है। वास्तव में यह वही है जो std :: map करता है।

— एंड्रयू टॉमाज़ोस

हां और नहीं ... यह निर्भर करता है कि आप "पेड़" से क्या मतलब है। std::mapआंतरिक रूप से btree के रूप में कार्यान्वित किया जाता है, लेकिन बाह्य रूप से यह PAIRS के क्रमबद्ध क्रम के रूप में प्रकट होता है। किसी भी तत्व को देखते हुए आप सार्वभौमिक रूप से पूछ सकते हैं कि कौन पहले है और कौन बाद में है। एक सामान्य वृक्ष संरचना जिसमें प्रत्येक तत्व होते हैं जिसमें कोई भी छंटाई या दिशा नहीं होती है। आप पुनरावृत्तियों को परिभाषित कर सकते हैं जो एक पेड़ की संरचना को कई तरीकों से चलते हैं (sallow | गहरा पहला | अंतिम ...) लेकिन एक बार जब आपने ऐसा कर लिया, तो std::treeकंटेनर को उनमें से किसी एक beginफ़ंक्शन से लौटना होगा । और एक या दूसरे को वापस करने का कोई स्पष्ट कारण नहीं है।

— एमिलियो गरवाग्लिया

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

— एंड्रयू टॉमाज़ोस

आपके उत्तर का निहितार्थ यह है कि कोई st-n-ट्री डेटा संरचना नहीं है क्योंकि इसमें "अनुक्रम" इंटरफ़ेस नहीं है। यह केवल गलत है।

— एंड्रयू टॉमाज़ोस

@EmiloGaravaglia: जैसा कि स्पष्ट है std::unordered_set, जिसके पास अपने सदस्यों को पुनरावृति करने का कोई "अनोखा तरीका" नहीं है (वास्तव में पुनरावृति क्रम छद्म यादृच्छिक और कार्यान्वयन परिभाषित है), लेकिन फिर भी एक stl कंटेनर है - जो आपकी बात का विरोध करता है। एक कंटेनर में प्रत्येक तत्व पर फेरबदल करना अभी भी एक उपयोगी ऑपरेशन है, भले ही आदेश अपरिभाषित हो।

— एंड्रयू टॉमाज़ोस

Answer 9

क्योंकि एसटीएल एक "सब कुछ" पुस्तकालय नहीं है। इसमें अनिवार्य रूप से, चीजों को बनाने के लिए आवश्यक न्यूनतम संरचनाएं शामिल हैं।

Comments

बाइनरी ट्री एक अत्यंत बुनियादी कार्यक्षमता है, और वास्तव में, std :: map, std :: multimap और stl :: सेट जैसे अन्य कंटेनरों की तुलना में अधिक बुनियादी है। चूंकि उन प्रकार उन पर आधारित हैं, आप उम्मीद करेंगे कि अंतर्निहित प्रकार उजागर हो।

— कैटस्कूल

मुझे नहीं लगता कि ओपी एक द्विआधारी पेड़ के लिए पूछ रहा है, वह एक पेड़ को पदानुक्रम संग्रहीत करने के लिए कह रहा है।

— मूइंग डक

इतना ही नहीं, एसटीएल में एक पेड़ "कंटेनर" जोड़ने का मतलब कई नई अवधारणाएं जोड़ना होगा, उदाहरण के लिए एक ट्री नेविगेटर (सामान्यीकरण Iterator)।

— alfC

"चीजों को बनाने के लिए न्यूनतम संरचनाएं" एक बहुत ही व्यक्तिपरक बयान है। आप कच्चे C ++ अवधारणाओं के साथ चीजों का निर्माण कर सकते हैं, इसलिए मुझे लगता है कि न्यूनतम न्यूनतम एसटीएल बिल्कुल नहीं होगा।

— doc

Answer 10

यह एक आशाजनक लग रहा है और लगता है कि आप क्या देख रहे हैं: http://tree.phi-sci.com/

Answer 11

IMO, एक चूक। लेकिन मुझे लगता है कि एसटीएल में ट्री स्ट्रक्चर को शामिल नहीं करने का अच्छा कारण है। एक पेड़ को बनाए रखने में बहुत तर्क है, जिसे आधार TreeNodeऑब्जेक्ट में सदस्य कार्यों के रूप में सबसे अच्छा लिखा गया है । जब TreeNodeएसटीएल हेडर में लपेटा जाता है, तो यह बस गड़बड़ हो जाता है।

उदाहरण के लिए:

template <typename T>
struct TreeNode
{
  T* DATA ; // data of type T to be stored at this TreeNode

  vector< TreeNode<T>* > children ;

  // insertion logic for if an insert is asked of me.
  // may append to children, or may pass off to one of the child nodes
  void insert( T* newData ) ;

} ;

template <typename T>
struct Tree
{
  TreeNode<T>* root;

  // TREE LEVEL functions
  void clear() { delete root ; root=0; }

  void insert( T* data ) { if(root)root->insert(data); } 
} ;

Comments

आपके पास वहां बहुत सारे कच्चे कच्चे मालिक हैं, जिनमें से कई को संकेत होने की कोई आवश्यकता नहीं है।

— मूइंग डक

सुझाव है कि आप इस उत्तर को वापस लें। ट्रीनोड क्लास एक पेड़ के कार्यान्वयन का हिस्सा है।

— ईनपोकलुम

Answer 12

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

एक परिमित जड़ वाले पेड़ को एक कंटेनर के रूप में सोचा जा सकता है जिसमें एक मूल्य या पेलोड है, एक वर्ग ए का उदाहरण और, जड़ (उप) पेड़ों का संभवतः खाली संग्रह; उप-पेड़ों के खाली संग्रह वाले पेड़ों को पत्तियों के रूप में माना जाता है।

template<class A>
struct unordered_tree : std::set<unordered_tree>, A
{};

template<class A>
struct b_tree : std::vector<b_tree>, A
{};

template<class A>
struct planar_tree : std::list<planar_tree>, A
{};

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

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

हालांकि, पेड़ों के अलावा "सह-पेड़" भी हैं; सभी पेड़ों के ऊपर संपत्ति है कि यदि आप रूट को हटाते हैं तो आप सब कुछ हटा देते हैं।

पेड़ पर चलने वालों पर विचार करें, शायद उन्हें पुनरावृत्तियों के एक साधारण ढेर के रूप में महसूस किया जाएगा, एक नोड के लिए, और इसके मूल तक, ... जड़ तक।

template<class TREE>
struct node_iterator : std::stack<TREE::iterator>{
operator*() {return *back();}
...};

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

पेड़ अविश्वसनीय रूप से उपयोगी हैं, उनके पास बहुत सारी संरचना है, यह निश्चित रूप से सही दृष्टिकोण प्राप्त करने के लिए एक गंभीर चुनौती है। मेरे विचार में यह एसटीएल में लागू नहीं किया गया है। इसके अलावा, अतीत में, मैंने देखा है कि लोग धार्मिक होते हैं और एक प्रकार के कंटेनर का विचार पाते हैं, जिसमें उसके अपने प्रकार के चुनौतीपूर्ण उदाहरण हैं - लेकिन उन्हें इसका सामना करना पड़ता है - यही एक पेड़ प्रकार का प्रतिनिधित्व करता है - यह एक नोड है जिसमें एक है संभवतः (छोटे) पेड़ों का खाली संग्रह। वर्तमान भाषा चुनौती देती है कि बिना डिफॉल्ट कंस्ट्रक्टर उपलब्ध कराए इसे चुनौती दी जा सकती है कि ए आदि के container<B>लिए ढेर (या कहीं और) पर जगह आवंटित न करें B।

मैं एक के लिए खुश होऊंगा अगर यह एक अच्छा रूप है, मानक में अपना रास्ता ढूंढें।

Answer 13

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

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

मेरा विचार था कि पेड़ मौजूदा एसटीएल कंटेनरों पर आधारित होना चाहिए और यह कंटेनर को छिपाना नहीं चाहिए, ताकि यह एसटीएल एल्गोरिदम के साथ उपयोग करने के लिए सुलभ हो।

पेड़ द्वारा प्रदान की जाने वाली अन्य महत्वपूर्ण विशेषता ट्रैवर्सिंग पुनरावृत्तियों है।

यहाँ मैं क्या करने में सक्षम था: https://github.com/igagis/utki/blob/master/src/utki/tree.hpp

और यहाँ परीक्षण हैं: https://github.com/igagis/utki/blob/master/tests/tree/stests.cpp

Answer 14

सभी एसटीएल कंटेनरों को पुनरावृत्तियों के साथ उपयोग किया जा सकता है। आपके पास एक पेड़ में एक इटरेटर नहीं हो सकता है, क्योंकि आपके पास पेड़ के माध्यम से '' एक सही '' रास्ता नहीं है।

Comments

लेकिन आप कह सकते हैं कि BFS या DFS सही तरीका है। या दोनों का समर्थन करते हैं। या कोई अन्य आप कल्पना कर सकते हैं। जट उपयोगकर्ता को बताएं कि यह क्या है।

— tomas789

एसटीडी में :: नक्शा वहाँ पेड़ है।

— जय

एक वृक्ष अपने स्वयं के कस्टम इट्रेटर प्रकार को परिभाषित कर सकता है, जो सभी नोड्स को एक "चरम" से दूसरे (यानी 0 और 1 के साथ किसी भी बाइनरी ट्री के लिए ट्रैवर्स करता है), यह एक इटेटर प्रदान कर सकता है जो "सभी 0s" से "सभी" तक जाता है 1s ", और एक रिवर्स इटरेटर कि विपरीत है, 3 की गहराई और शुरू करने नोड के साथ एक पेड़ के लिए s, उदाहरण के लिए, इस पर नोड्स पुनरावृति सकता है के रूप में s000, s00, s001, s0, s010, s01, s011, s, s100, s10, s101, s1, s110, s11, s111(" सबसे बाईं ओर दायीं ")" के लिए ", यह भी गहराई ट्रेवर्सल पैटर्न इस्तेमाल कर सकते हैं ( s, s0, s1, s00, s01, s10, s11,

— जस्टिन टाइम -

, आदि), या कुछ अन्य पैटर्न, जब तक कि यह प्रत्येक नोड पर इस तरह से पुनरावृत्त हो जाता है कि प्रत्येक को केवल एक बार पारित किया जाता है।

— जस्टिन टाइम -

@ डॉक, बहुत अच्छी बात है। मुझे लगता है कि std::unordered_setएक "सीक्वेंस" बनाया गया था क्योंकि हम कुछ मनमाने तरीके (आंतरिक रूप से हैश फ़ंक्शन द्वारा दिए गए) के अलावा अन्य तत्वों पर पुनरावृत्ति का एक बेहतर तरीका नहीं जानते हैं। मुझे लगता है कि यह पेड़ के विपरीत मामला है: अधिक unordered_setसे अधिक पुनरावृत्ति अंडरसीज़ है, सिद्धांत रूप में शायद "बेतरतीब ढंग से" के अलावा एक पुनरावृत्ति को परिभाषित करने का "कोई रास्ता नहीं" है। पेड़ के मामले में कई "अच्छे" (गैर यादृच्छिक) तरीके हैं। लेकिन, फिर, आपकी बात मान्य है।

— alfC