View source for संक्षिप्त डेटा संरचना

[[कंप्यूटर विज्ञान]] में, संक्षिप्त [[डेटा संरचना]] वह डेटा संरचना है जो अन्तराल की मात्रा का उपयोग करती है, जो [[सूचना-सैद्धांतिक]] निचली सीमा के निकट है, लेकिन (अन्य संपीड़ित अभ्यावेदन के विपरीत) अभी भी प्रभावशाली क्वेरी संचालन की अनुमति देता है। अवधारणा मूल रूप से जैकबसन द्वारा पेश की गई थी<ref name="jacobson1988succinct"/>[[बिट वेक्टर]], (लेबल रहित) [[पेड़ (डेटा संरचना)|ट्री (डेटा संरचना)]], और [[प्लेनर ग्राफ]] को एन्कोड करने के लिए सामान्य दोषरहित डेटा कम्प्रेशन एल्गोरिदम के विपरीत, संक्षिप्त डेटा संरचनाएँ पहले उन्हें विघटित किए बिना, उन्हें इन-प्लेस उपयोग करने की क्षमता बनाए रखती हैं। एक संबंधित धारणा एक [[संकुचित डेटा संरचना]] की है, जिसमें डेटा संरचना का आकार प्रतिनिधित्व किए जा रहे विशेष डेटा पर निर्भर करता है।

माना कि <math>Z</math> कुछ डेटा को स्टोर करने के लिए आवश्यक बिट्स की सूचना-सैद्धांतिक इष्टतम संख्या है। इस डेटा का एक प्रतिनिधित्व कहा जाता है:

* निहित डेटा संरचना यदि यह लेता है <math>Z + O(1)</math> अन्तराल के बिट्स,
* यदि लगे तो संक्षिप्त करें <math>Z + o(Z)</math> अन्तराल के बिट्स, और
* कॉम्पैक्ट अगर यह लेता है <math>O(Z)</math> अन्तराल के बिट्स।

उदाहरण के लिए, एक डेटा संरचना जो उपयोग करती है <math>2Z</math> भंडारण के बिट्स कॉम्पैक्ट हैं, <math>Z + \sqrt{Z}</math> बिट संक्षिप्त है, <math>Z + \lg Z</math> बिट भी संक्षिप्त है, और <math>Z + 3</math> बिट्स निहित है।

इस प्रकार अंतर्निहित संरचनाएं सामान्यतः इनपुट डेटा के कुछ क्रमपरिवर्तन का उपयोग करके जानकारी संग्रहीत करने के लिए कम हो जाती हैं; इसका सबसे प्रसिद्ध उदाहरण हीप (डेटा संरचना) है।

== संक्षिप्त शब्दकोश ==
सक्सेस इंडेक्सेबल डिक्शनरी, जिसे रैंक/सिलेक्ट डिक्शनरी भी कहा जाता है, [[बाइनरी पेड़|बाइनरी ट्री]] सहित कई सक्सेसफुल रिप्रेजेंटेशन तकनीकों का आधार बनता है, <math>k</math>-एरी ट्री और [[मल्टीसेट]],<ref name="raman2002succinct"/>साथ ही प्रत्यय ट्री और [[प्रत्यय सरणी]]<ref name="sadakane2006squeezing"/>मूल समस्या एक सबसेट को स्टोर करना है <math>S</math> एक अंतराल का <math>U =
[0 \dots n) = \{0, 1, \dots, n - 1\}</math>, सामान्यतः एक बिट सरणी के रूप में दर्शाया जाता है <math>B[0 \dots n)</math> कहाँ <math>B[i] = 1</math> आईएफएफ <math>i \in S.</math> एक इंडेक्सेबल डिक्शनरी (क्वेरी, और डायनामिक केस में इंसर्शन/डिलीशन) के साथ-साथ निम्नलिखित ऑपरेशंस पर सामान्य तरीकों का समर्थन करता है:

*<math>\mathbf{rank}_q(x) = |\{ k \in [0 \dots x] : B[k] = q \}|</math>
*<math>\mathbf{select}_q(x)= \min \{k \in [0 \dots n) : \mathbf{rank}_q(k) = x\}</math>
के लिए <math>q \in \{0, 1\}</math>.

दूसरे शब्दों में, <math>\mathbf{rank}_q(x)</math> के बराबर तत्वों की संख्या देता है <math>q</math> स्थिति तक <math>x</math> जबकि <math>\mathbf{select}_q(x)</math> की स्थिति लौटाता है <math> x</math>-वीं घटना <math> q </math> है।

एक साधारण प्रतिनिधित्व है<ref name="jacobson1989space"/>जो उपयोग करता है <math>n + o(n)</math> भंडारण स्थान के बिट्स (मूल बिट सरणी और a <math>o(n)</math> सहायक संरचना) और रैंक का समर्थन करता है और निरंतर समय में चयन करता है। यह [[रेंज न्यूनतम क्वेरी]] रेंज-मिनिमम क्वेरीज; सीमित आकार की उप-समस्या पर रुकने से पहले निरंतर संख्या में पुनरावर्तन होते हैं। बिट सरणी <math>B</math> आकार के बड़े ब्लॉकों में बांटा गया है <math>l = \lg^2 n</math> बिट्स और आकार के छोटे ब्लॉक <math>s = \lg n / 2</math> बिट्स प्रत्येक बड़े ब्लॉक के लिए, उसके पहले बिट का रैंक एक अलग तालिका में संग्रहीत किया जाता है <math>R_l[0 \dots n/l)</math>; प्रत्येक ऐसी प्रविष्टि लेता है <math>\lg n</math> कुल के लिए बिट्स <math>(n/l) \lg n = n / \lg n</math> भंडारण के बिट्स एक बड़े ब्लॉक के भीतर, दूसरी निर्देशिका <math>R_s[0 \dots l/s)</math> प्रत्येक के रैंक को स्टोर करता है <math>l/s = 2 \lg n</math> इसमें छोटे ब्लॉक होते हैं। यहाँ अंतर यह है कि इसकी केवल आवश्यकता है <math>\lg l = \lg \lg^2 n = 2 \lg \lg n</math> प्रत्येक प्रविष्टि के लिए बिट्स, क्योंकि बड़े ब्लॉक वाले पहले बिट के रैंक से केवल अंतर को संग्रहीत करने की आवश्यकता होती है। इस प्रकार, यह तालिका कुल <math>(n/s) \lg l = 4 n \lg \lg n / \lg n</math> बिट्स लेती है। एक लुकअप टेबल <math>R_p</math> तब उपयोग किया जा सकता है जो हर संभव रैंक क्वेरी के उत्तर को लंबाई के एक बिट स्ट्रिंग पर संग्रहीत करता है <math>s</math> के लिए <math>i \in [0, s)</math>; इस आवश्यकता है <math>2^s s \lg s = O(\sqrt{n} \lg n \lg \lg n)</math> भंडारण स्थान के बिट्स इस प्रकार, चूंकि इनमें से प्रत्येक सहायक तालिका लेती है <math>o(n)</math> अन्तराल, यह डेटा संरचना रैंक प्रश्नों का समर्थन करती है <math>O(1)</math> समय और <math>n + o(n)</math> अन्तराल के बिट्स एक स्थिर समय एल्गोरिथम गणना करता है,

एक प्रश्न का उत्तर देने के लिए <math>\mathbf{rank}_1(x)</math> निरंतर समय में, एक स्थिर समय एल्गोरिथम गणना करता है:

* <math>\mathbf{rank}_1(x) = R_l[\lfloor x / l \rfloor] + R_s[\lfloor x / s\rfloor] + R_p[x \lfloor x / s\rfloor, x \text{ mod } s]</math>
व्यवहार में, लुकअप तालिका <math>R_p</math> बिटवाइज़ ऑपरेशंस और छोटी तालिकाओं द्वारा प्रतिस्थापित किया जा सकता है जिनका उपयोग छोटे ब्लॉकों में सेट बिट्स की संख्या का पता लगाने के लिए किया जा सकता है। यह अक्सर फायदेमंद होता है, क्योंकि संक्षिप्त डेटा संरचनाएं बड़े डेटा सेट में अपना उपयोग ढूंढती हैं, इस मामले में कैश की कमी बहुत अधिक हो जाती है और लुकअप टेबल को करीबी सीपीयू कैश से बेदखल करने की संभावना अधिक हो जाती है।<ref name="gonzález2005practical" />रैंक के लिए उपयोग की जाने वाली समान सहायक संरचना पर बाइनरी खोज करके चुनिंदा प्रश्नों का आसानी से समर्थन किया जा सकता है; हालाँकि, यह लेता है <math>O(\lg n)</math> सबसे खराब स्थिति में समय। एक अधिक जटिल संरचना का उपयोग करना <math>3n/\lg \lg n + O(\sqrt{n} \lg n \lg \lg n) = o(n)</math> निरंतर समय में चयन का समर्थन करने के लिए अतिरिक्त संग्रहण के बिट्स का उपयोग किया जा सकता है।<ref name="clark1998compact" />व्यवहार में, इनमें से कई समाधानों में छिपे हुए स्थिरांक हैं <math>O(\cdot)</math> संकेतन जो किसी भी स्पर्शोन्मुख लाभ के स्पष्ट होने से पहले हावी हो जाता है; व्यापक शब्द संचालन और शब्द-संरेखित ब्लॉक का उपयोग करने वाले कार्यान्वयन अक्सर अभ्यास में बेहतर प्रदर्शन करते हैं।<ref name="vigna2008broadword" />



== एंट्रॉपी-संपीड़ित शब्दकोश ==
<math>n + o(n)</math> h> अन्तराल दृष्टिकोण को ध्यान में रखते हुए सुधार किया जा सकता है <math>\textstyle \binom{n}{m}</math> अलग <math>m</math>-उपसमुच्चय <math>[n)</math> (या लंबाई के बाइनरी तार <math>n</math> साथ बिल्कुल <math>m</math> 1), और इस प्रकार <math>\textstyle \mathcal{B}(m,n) = \lceil \lg \binom{n}{m} \rceil</math> एक सूचना सिद्धांत है जो स्टोर करने के लिए आवश्यक बिट्स की संख्या पर कम है <math>B</math>. एक संक्षिप्त (स्थैतिक) शब्दकोश है जो इस सीमा को प्राप्त करता है, अर्थात् उपयोग करना <math>\mathcal{B}(m,n) + o(\mathcal{B}(m,n))</math> अन्तराल।<ref name="brodnik1999membership" />इस संरचना को रैंक का समर्थन करने और प्रश्नों का चयन करने और लेने के लिए बढ़ाया जा सकता है <math>\mathcal{B}(m,n) + O(m + n \lg \lg n / \lg n)</math> अन्तराल।<ref name="raman2002succinct" />इस संरचना में सही रैंक प्रश्न हालांकि सेट में निहित तत्वों तक सीमित हैं, जो न्यूनतम पूर्ण हैशिंग फ़ंक्शन के काम करने के अनुरूप है। डिक्शनरी के स्टोरेज स्पेस को कम करके इस बाउंड को स्पेस/टाइम ट्रेडऑफ़ में कम किया जा सकता है, डेटा संरचना किसी कंप्यूटर सिस्टम में डेटा को स्टोर तथा व्यवस्थित करने का एक तरीका होता है। जिससे कि हम डेटा का आसानी से इस्तेमाल कर सकें, अर्थात डेटा को इस प्रकार स्टोर तथा व्यवस्थित किया जाता है कि उसको बाद में किसी भी समय आसानी से एक्सेस किया जा सकें।<ref name="patrascu2008succincter" />


== उदाहरण ==
एक [[अशक्त-समाप्त स्ट्रिंग]] ([[सी स्ट्रिंग]]) Z + 1 स्थान लेती है, और इस प्रकार निहित है। मनमाना लंबाई ([[पास्कल स्ट्रिंग]]) के साथ एक स्ट्रिंग Z + लॉग (Z) स्थान लेती है, और इस प्रकार संक्षिप्त होती है। यदि अधिकतम लंबाई है - जो व्यवहार में मामला है, चूंकि 2<sup>32</sup> = 4 GiB डेटा एक बहुत लंबी स्ट्रिंग है, और 2<sup>64</sup> = 16 EiB डेटा व्यवहार में किसी भी स्ट्रिंग से बड़ा है - फिर लंबाई के साथ एक स्ट्रिंग भी निहित है, Z + k स्पेस लेते हुए, जहाँ k अधिकतम लंबाई का प्रतिनिधित्व करने के लिए डेटा की संख्या है (जैसे, 64 बिट्स)।

जब चर-लंबाई वाली वस्तुओं (जैसे तार) के अनुक्रम को एन्कोड करने की आवश्यकता होती है, तो विभिन्न संभावनाएँ होती हैं। एक सीधा तरीका प्रत्येक रिकॉर्ड में एक लंबाई और एक आइटम को स्टोर करना है - फिर इन्हें एक के बाद एक रखा जा सकता है। यह प्रभावशाली अगले की अनुमति देता है, लेकिन kth आइटम नहीं ढूंढता है। एक विकल्प यह है कि वस्तुओं को एक सीमांकक के साथ क्रम में रखा जाए (उदाहरण के लिए, अशक्त-समाप्त स्ट्रिंग) यह एक लंबाई के बजाय एक सीमांकक का उपयोग करता है, और काफी धीमा है, क्योंकि पूरे अनुक्रम को सीमांकक के लिए स्कैन किया जाना चाहिए। ये दोनों अन्तराल-प्रभावशाली हैं। एक वैकल्पिक दृष्टिकोण आउट-ऑफ़-बैंड अलगाव है: वस्तुओं को बिना किसी सीमांकक के एक के बाद एक रखा जा सकता है। आइटम सीमाओं को इस क्रम में लंबाई, या बेहतर, ऑफ़सेट के अनुक्रम के रूप में संग्रहीत किया जा सकता है। वैकल्पिक रूप से, एक अलग बाइनरी स्ट्रिंग जिसमें आइटम शुरू होने वाले स्थान पर 1s होता है, और 0s हर जगह इसके साथ एन्कोड किया जाता है। इस स्ट्रिंग को देखते हुए, <math>select</math> फ़ंक्शन जल्दी से यह निर्धारित कर सकता है कि प्रत्येक आइटम कहाँ से शुरू होता है, इसकी अनुक्रमणिका दी गई है।<ref>{{cite web|url=http://cmph.sourceforge.net/papers/esa09.pdf |title=हैश, विस्थापित और संपीड़ित करें|last=Belazzougui|first=Djamal}}</ref> यह कॉम्पैक्ट है लेकिन संक्षिप्त नहीं है, क्योंकि यह 2Z स्थान लेता है, जो O(Z) है।

एक अन्य उदाहरण एक [[बाइनरी ट्री]] का प्रतिनिधित्व है: एक मनमाना बाइनरी ट्री ऑन <math>n</math> नोड्स में प्रदर्शित किया जा सकता है <math>2n + o(n)</math> बिट्स किसी भी नोड पर विभिन्न प्रकार के संचालन का समर्थन करते हुए, जिसमें इसके माता-पिता, इसके बाएं और दाएं बच्चे को ढूंढना और इसके सबट्री के आकार को वापस करना शामिल है, प्रत्येक निरंतर समय में। विभिन्न बाइनरी ट्रीों की संख्या <math>n</math> नोड्स है <math>{\tbinom{2n}{n}}</math><math>/(n+1)</math>. बड़े के लिए <math>n</math>, इस बारे में है <math>4^n</math>; इस प्रकार हमें कम से कम चाहिए <math>\log_2(4^n)=2n</math> इसे एनकोड करने के लिए बिट्स। एक संक्षिप्त बाइनरी ट्री इसलिए केवल कब्जा करेगा <math>2</math> बिट्स प्रति नोड।

== यह भी देखें ==
* [[मिनिमल परफेक्ट हैश फंक्शन]]
* जीरो-नॉलेज_प्रूफ जीरो-नॉलेज प्रूफ प्रोटोकॉल ज्ञान के संक्षिप्त गैर-संवादात्मक तर्क

==संदर्भ==
<references>
<ref name="jacobson1988succinct">
{{Cite thesis
| type = Ph.D. thesis
| last = Jacobson
| first = G. J
| title = Succinct static data structures
| year = 1988
| publisher = Carnegie Mellon University
| location = Pittsburgh, PA
}}
</ref>
<ref name="raman2002succinct">
{{Cite conference
| isbn = 0-89871-513-X
| pages = [https://archive.org/details/proceedingsofthi2002acms/page/233 233–242]
| last = Raman
| first = R.
| author2 = V. Raman
| author3 = S. S Rao
| title = Succinct indexable dictionaries with applications to encoding k-ary trees and multisets
| book-title = Proceedings of the thirteenth annual ACM-SIAM symposium on Discrete algorithms
| date = 2002
| url = https://archive.org/details/proceedingsofthi2002acms/page/233
| doi = 10.1145/1290672.1290680 | citeseerx = 10.1.1.246.3123 | arxiv = 0705.0552
}}
</ref>
<ref name="sadakane2006squeezing">
{{Cite conference
 |isbn        = 0-89871-605-5
 |pages       = 1230–1239
 |last        = Sadakane
 |first       = K.
 |author2     = R. Grossi
 |title       = Squeezing succinct data structures into entropy bounds
 |book-title   = Proceedings of the seventeenth annual ACM-SIAM symposium on Discrete algorithm
 |date        = 2006
 |url         = http://www.dmi.unisa.it/people/cerulli/www/WSPages/WSFiles/Abs/S3/S33_abs_Grossi.pdf
 |url-status     = dead
 |archive-url  = https://web.archive.org/web/20110929230740/http://www.dmi.unisa.it/people/cerulli/www/WSPages/WSFiles/Abs/S3/S33_abs_Grossi.pdf
 |archive-date = 2011-09-29
}}
</ref>
<ref name="jacobson1989space">
{{Cite conference
| last = Jacobson
| first = G.
| title = Space-efficient static trees and graphs
| date = 1 November 1989
| conference = 30th IEEE Symposium on Foundations of Computer Science
| doi = 10.1109/SFCS.1989.63533 
| url = https://www.computer.org/csdl/proceedings/focs/1989/1982/00/063533.pdf
| archive-url = https://web.archive.org/web/20160312010342/https://www.computer.org/csdl/proceedings/focs/1989/1982/00/063533.pdf
| archive-date = 2016-03-12
}}
</ref>
<ref name="gonzález2005practical">
{{Cite conference
| pages = 27–38
| last = González
| first = R.
|author2=S. Grabowski |author3=V. Mäkinen |author4=G. Navarro
| title = Practical implementation of rank and select queries
| book-title = Poster Proceedings Volume of 4th Workshop on Efficient and Experimental Algorithms (WEA)
| date = 2005
| url = http://www.dcc.uchile.cl/~gnavarro/algoritmos/ps/wea05.pdf
}}
</ref>
<ref name="clark1998compact">
{{Cite thesis
| type = Ph.D. thesis
| last = Clark
| first = David
| title = Compact pat trees
| year = 1996
| publisher = University of Waterloo
| url = https://uwspace.uwaterloo.ca/bitstream/10012/64/1/nq21335.pdf
}}
</ref>
<ref name="vigna2008broadword">
{{Cite book
| pages = 154–168
| last = Vigna
| first = S.
| title = Broadword implementation of rank/select queries
| journal = Experimental Algorithms
| year = 2008
| url = http://sux.di.unimi.it/paper.pdf
| doi = 10.1007/978-3-540-68552-4_12
| series = Lecture Notes in Computer Science
| isbn = 978-3-540-68548-7
| volume = 5038
| citeseerx = 10.1.1.649.8950
}}
</ref>
<ref name="brodnik1999membership">
{{Cite journal
| volume = 28
| issue = 5
| pages = 1627–1640
| last = Brodnik
| first = A.
|author2=J. I Munro
 | title = Membership in constant time and almost-minimum space
| journal = SIAM J. Comput.
| year = 1999
| url = https://www.cs.cmu.edu/afs/cs.cmu.edu/project/aladdin/wwwlocal/compression/BM99.pdf
| doi = 10.1137/S0097539795294165
| citeseerx = 10.1.1.530.9223
}}
</ref>
<ref name="patrascu2008succincter">
{{Cite conference
| pages = 305–313
| last = Pătraşcu
| first = M. | author-link = Mihai Pătrașcu (computer scientist)
| title = Succincter
| book-title = Foundations of Computer Science, 2008. FOCS'08. IEEE 49th Annual IEEE Symposium on
| date = 2008
| url = http://people.csail.mit.edu/mip/papers/succinct/succinct.pdf
}}
</ref>
</references>

{{DEFAULTSORT:Succinct Data Structure}}

[[Category:Created On 24/02/2023|Succinct Data Structure]]
[[Category:Machine Translated Page|Succinct Data Structure]]
[[Category:Pages with reference errors|Succinct Data Structure]]
[[Category:Templates Vigyan Ready|Succinct Data Structure]]
[[Category:संक्षिप्त डेटा संरचना| संक्षिप्त डेटा संरचना ]]