खंड पेड़, अंतराल पेड़, द्विआधारी अनुक्रमित पेड़ और श्रेणी के पेड़ के बीच अंतर क्या हैं?

Question

सेगमेंट ट्री, अंतराल ट्री, बाइनरी इंडेक्स ट्री और रेंज ट्री के बीच क्या अंतर हैं:

• मुख्य विचार / परिभाषा
• अनुप्रयोग
• उच्च आयाम / अंतरिक्ष खपत में प्रदर्शन / आदेश

कृपया केवल परिभाषाएँ न दें।

Comments

यह एक डुप्लिकेट नहीं है, यह सवाल है कि अगर फेनविक पेड़ों का अंतराल अंतराल का सामान्यीकरण है, और मेरा प्रश्न अधिक विशिष्ट और अलग है।

— आदित्य

इसका जवाब stackoverflow.com/questions/2795989/… पर नहीं दिया गया है , इसका उत्तर सिर्फ परिभाषा देता है।

— आदित्य

यह कैसे व्यापक है? "X और y के बीच कुछ अंतर क्या हैं?" यह जितना स्पष्ट और केंद्रित है। यह एक बहुत अच्छा सवाल है।

— IVlad

और कहीं भी इसके लिए कोई अच्छा जवाब उपलब्ध नहीं है। एक अच्छा जवाब समुदाय के लिए बहुत अच्छा होगा

— आदित्य

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

— एवगेनी क्लूव

Answer 1

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

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

एक आयाम के लिए प्रदर्शन / अंतरिक्ष की खपत:

• सेगमेंट ट्री - O (n logn) प्रीप्रोसेसिंग टाइम, O (k + logn) क्वेरी टाइम, O (n logn) स्पेस
• अंतराल वृक्ष - O (n logn) पूर्वप्रक्रमक समय, O (k + logn) क्वेरी समय, O (n) स्थान
• रेंज ट्री - O (n logn) प्रीप्रोसेसिंग टाइम, O (k + logn) क्वेरी टाइम, O (n) स्पेस
• बाइनरी अनुक्रमित पेड़ - O (n logn) प्रीप्रोसेसिंग टाइम, O (logn) क्वेरी टाइम, O (n) स्पेस

(k सूचित परिणामों की संख्या है)।

सभी डेटा संरचनाएँ गतिशील हो सकती हैं, इस अर्थ में कि उपयोग परिदृश्य में डेटा परिवर्तन और प्रश्न दोनों शामिल हैं:

• सेगमेंट ट्री - अंतराल को O (logn) समय में जोड़ा / हटाया जा सकता है ( यहाँ देखें )
• अंतराल वृक्ष - अंतराल को O (logn) समय में जोड़ा / हटाया जा सकता है
• रेंज ट्री - O (logn) समय में नए बिंदु जोड़े / हटाए जा सकते हैं ( यहां देखें )
• बाइनरी इंडेक्स ट्री - आइटमों की गणना प्रति इंडेक्स ओ (लॉगन) समय में बढ़ाई जा सकती है

उच्च आयाम (d> 1):

• खंड वृक्ष - O (n (logn) ^ d) पूर्वप्रक्रमक समय, O (k + (logn) ^ d) क्वेरी समय, O (n (logn) ^ (d-1)) स्थान
• अंतराल वृक्ष - O (n logn) पूर्वप्रक्रमक समय, O (k + (logn) ^ d) क्वेरी समय, O (n logn) स्थान
• रेंज ट्री - O (n (logn) ^ d) प्रीप्रोसेसिंग टाइम, O (k + (logn) ^ d) क्वेरी टाइम, O (n (logn) ^ (d-1)) स्पेस
• बाइनरी अनुक्रमित पेड़ - O (n (logn) ^ d) पूर्वप्रक्रमक समय, O ((logn) ^ d) क्वेरी समय, O (n (logn) ^ d) स्थान

Comments

मुझे वास्तव में यह धारणा है कि खंड के पेड़ <इस से अंतराल के पेड़। क्या किसी खंड के पेड़ को पसंद करने का कोई कारण है? ईजी कार्यान्वयन सादगी?

— j_random_hacker

@j_random_hacker: सेगमेंट ट्री आधारित एल्गोरिदम में अंतराल क्वेरी के कुछ अधिक जटिल उच्च-आयामी वेरिएंट में फायदे हैं। उदाहरण के लिए, जो गैर-धुरी-समानांतर रेखा-खंडों को एक 2 डी खिड़की के साथ मिलाता है।

— लियोर कोगन

धन्यवाद, मुझे आपके द्वारा दिए गए किसी भी विस्तार में दिलचस्पी होगी।

— j_random_hacker

@j_random_hacker, सेगमेंट के पेड़ों का एक और दिलचस्प उपयोग है: आरएमक्यूएस (रेंज न्यूनतम प्रश्न) ओ (लॉग एन) समय में जहां एन समग्र अंतराल आकार है।

— ars-longa-vita-brevis

सेगमेंट ट्री O (n लॉग एन) स्पेस क्यों हैं? वे एन पत्ते + एन / 2 + एन / 4 + ... + एन / 2 ^ (लॉग एन) स्टोर करते हैं, और यह योग ओ (एन) है अगर मैं गलत नहीं हूं। इसके अलावा @ icc97 उत्तर भी O (N) स्पेस की रिपोर्ट करता है।

— Ant

Answer 2

ऐसा नहीं है कि मैं लाइर के उत्तर में कुछ भी जोड़ सकता हूं , लेकिन ऐसा लगता है कि यह एक अच्छी तालिका के साथ कर सकता है।

एक आयाम

k रिपोर्ट किए गए परिणामों की संख्या है

|              | Segment       | Interval   | Range          | Indexed   |
|--------------|--------------:|-----------:|---------------:|----------:|
|Preprocessing |        n logn |     n logn |         n logn |    n logn |
|Query         |        k+logn |     k+logn |         k+logn |      logn |
|Space         |        n logn |          n |              n |         n |
|              |               |            |                |           |
|Insert/Delete |          logn |       logn |           logn |      logn |

उच्च आयाम

d > 1

|              | Segment       | Interval   | Range          | Indexed   |
|--------------|--------------:|-----------:|---------------:|----------:|
|Preprocessing |     n(logn)^d |     n logn |      n(logn)^d | n(logn)^d |
|Query         |    k+(logn)^d | k+(logn)^d |     k+(logn)^d |  (logn)^d |
|Space         | n(logn)^(d-1) |     n logn | n(logn)^(d-1)) | n(logn)^d |

इन तालिकाओं Github प्रारूपित Markdown में बनाए जाते हैं - यह देखने सार यदि आप टेबल ठीक से स्वरूपित करना चाहते हैं।

Comments

रिपोर्ट किए गए परिणामों से आपका क्या अभिप्राय है?

— प्रतीक सिंघल

@ ps06756 खोज एल्गोरिदम में अक्सर लॉग का एक रनटाइम होता है (n) जहां n इनपुट होता है, लेकिन ऐसे परिणाम निकाल सकते हैं जो n में रैखिक होते हैं जो logarithmic समय में नहीं किया जा सकता है (लॉग में n संख्या को आउटपुट करना (n) समय संभव नहीं है) ।

— oerpli

क्या सेगमेंट ट्री को O(n logn) spaceपहली तालिका में नहीं होना चाहिए ?

— Danny_ds