सेट अंतर के लिए डेटा संरचना?

21

क्या कोई डेटा संरचना है जो निम्नलिखित कार्यों का समर्थन करते हुए सेट (परिमित ग्राउंड सेट) का संग्रह बनाए रखती है? किसी भी उदासीन चल रहे समय की सराहना की जाएगी?

एक खाली सेट में प्रवेश करें।
एक सेट में एक तत्व जोड़ें।
दो सेट को देखते हुए, रिपोर्ट करें कि क्या वे प्रतिच्छेद करते हैं।

data-structures sets

— दावई हुआंग
स्रोत

1

यह एक बहुत ही सामान्य प्रश्न है, क्योंकि कोई भी डेटा संरचना परिमित डोमेन के साथ उन कार्यों का समर्थन कर सकती है। क्या आपके द्वारा कुछ अधिक विशिष्ट हुआ जा सकता है ? उदाहरण के लिए। आपको किस जटिलता की आवश्यकता है, आप सेट ऑपरेशन आदि प्राप्त करने के लिए क्या बलिदान करना चाहते हैं

— बार्टोज़ प्रेज़ीबल्स्की

13

यदि प्रत्येक सेट में अन्य सेट मौजूद हैं, और आपके पास कुल $s > 0$ सेट का रिकॉर्ड है, तो आप किसी संग्रह के लिए किसी भी डेटा संरचना को आसानी से चालू कर सकते हैं ( जैसे बाइनरी सर्च ट्री, इत्यादि ) जिसमें आप पुनर्प्राप्ति कर सकते हैं। में दो सेटों के प्रतिच्छेदन का एक तत्व $O(\log s)$ ।

प्रत्येक सेट में कुछ पूरी तरह से ऑर्डर किए गए सेट से एक अद्वितीय पहचानकर्ता होना चाहिए। यदि आप स्पष्ट रूप से अपने सेट नाम रखते हैं $S_1, S_2, \ldots$ तो पहचानकर्ता सिर्फ सूचकांक हो सकता है।
आपको सेट की "रजिस्ट्री" को लागू करना चाहिए; एक डेटा संरचना जो आपके द्वारा परिभाषित सभी सेटों का एक संग्रह रखता है। रजिस्ट्री को खोज-ट्री डेटा संरचना के रूप में लागू किया जाना चाहिए, ताकि आसान पुनर्प्राप्ति की अनुमति दी जा सके ( जैसे यदि आप सेट को हटाना चाहते हैं) और सेट के रैखिक-समय ट्रैवर्सल।
प्रत्येक सेट अन्य सेटों में से प्रत्येक का "इंडेक्स" भी बनाए रखता है - उनकी प्रति नहीं , बल्कि एक डेटा संरचना जो अन्य सेट के लेबल द्वारा अनुक्रमित होती है। इस इंडेक्स का उपयोग प्रत्येक सेट , के सभी तत्वों के एक द्विआधारी खोज ट्री के लिए किया जाएगा । (दो सेट और उस खोज ट्री की एक प्रति साझा करते हैं।) $S_j$ $S_k$ $S_j \cap S_k$ $S_j$ $S_k$

प्रारंभ

एक सेट के प्रारंभ के होते के संचालन उसके तत्वों का पेड़ प्रारंभ करने, आपरेशन के रूप में आप को प्रारंभ (रजिस्ट्री से कॉपी) सेट के लिए सूचकांक , और आप के रूप में संचालन रजिस्ट्री जोड़ने के लिए पार अन्य सेटों में से प्रत्येक के सूचकांकों में । के सूचकांक में , हम का प्रतिनिधित्व खोज पेड़ बनाने $T = \varnothing$ $O(1)$ $O(s)$ $T$ $O(s \log s)$ $T$ $S_j$ $T$ $T \cap S_j = \varnothing$ अन्य सेटों के लिए ; हम के सूचकांक के लिए उसी पॉइंटर को कॉपी करते हैं । $S_j$ $S_j$

एक सेट एक तत्व जोड़ना $T$

कुछ जोड़ा जा रहा है सेट करने के लिए समय लगता हमेशा की तरह है, जहां के रूप में । हम यह भी की सदस्यता के लिए परीक्षण अन्य सेट में से प्रत्येक में , जो समय लगता है $x \in V$ $T$ $O(\log n_T)$ $n_T = |T|$ $x$ $S_1, S_2, \ldots$ जहाँब्रह्मांड का आकार (या सबसे बड़ा सेट ) है और रजिस्ट्री में सेट की संख्या है। प्रत्येक सेट के लिए ऐसी है कि , यह भी डालने सेट के लिए सूचकांक में । ऐसे प्रत्येक सेट के लिए , इस लेता को देखने के लिए समय,

O (\log n_{S_{1}} + \log n_{S_{2}} + \dots) \subseteq O (s \log n),

$O(\log n_{S_1} + \log n_{S_2} + \cdots) \subseteq O(s \log n) ,$

n = | V |

$n = |V|$

S_{j}

$S_j$

s

$s$

S_{j}

$S_j$

x \in S_{j}

$x \in S_j$

x

$x$

S_{j} \cap T

$S_j \cap T$

S_{j}

$S_j$

O (\log s + \log n_{T})

$O(\log s + \log n_T)$

S_{j}

$S_j$ को इंडेक्स में देखने के लिए

और करने के लिए डालने

में

; सभी सेटों में

इसमें समय लगता है

। अगर हम मान लें कि सेट की संख्या

ज्यादा ब्रह्मांड के आकार से कम है

(जो है, अगर हम मान लें कि

), तत्व प्रविष्टि के लिए कुल समय तो है

।

T

$T$

x

$x$

S_{j} \cap T

$S_j \cap T$

S_{1}, S_{2}, \dots

$S_1, S_2, \ldots$

O (s \log s + s \log n_{T})

$O(s \log s + s \log n_T)$

S_{j}

$S_j$

V

$V$

s ≪ n

$s \ll n$

O (s \log n)

$O(s \log n)$

आप सेट में डुप्लिकेट की अनुमति नहीं देते हैं, तो हम इस मामले में समय बचा सकते हैं कि पहले से ही सदस्यता परीक्षण और अन्य सेट के लिए सम्मिलन forgoing द्वारा । "सम्मिलन" उस स्थिति में जब पहले से मौजूद है तो केवल समय लगता है । $x \in S$ $T$ $x$ $O(\log n_T)$

अंतःक्रिया परीक्षण

प्रत्येक सेट का सूचकांक सटीक रूप से बनाए रखा जाता है ताकि दो सेट और प्रतिच्छेदन का त्वरित मूल्यांकन हो सके । एक सेट के लिए , बस सेट के लिए अपने सूचकांक की जाँच करके , हम केवल कुछ ही समय में निर्धारित नहीं कर सकता या नहीं, intersects , लेकिन हम भी एक द्विआधारी पूरे सेट युक्त पेड़ प्राप्त कर सकते हैं । $S_j$ $S_k$ $S_j$ $S_k$ $O(\log s)$ $S_j$ $S_k$ $S_j \cap S_k$

तत्व निकालना

एक तत्व को हटाने के लिए एक सेट से , हम इसे न केवल खोज के लिए पेड़ से हटाने ही है, लेकिन चौराहों में से प्रत्येक से सेट के लिए अपने सूचकांक में। इसमें समय लगता है , जहां । $x$ $T$ $T$ $S_j \cap T$ $S_j$ $O(s \log n_T)$ $n_T = |T|$

हटाओ सेट

रजिस्ट्री को खोजने के ओवरहेड के कारण, यदि आपके पास कई सेट हैं, तो सेट को हटाने के लिए वांछनीय हो सकता है, क्योंकि उन्हें अब ज़रूरत नहीं है। संपूर्ण रजिस्ट्री का पता लगाकर, हम को हटा सकते हैं $S$ from the index of all other sets $S_j$ in time $O(sn_T)$ , dominated by the cost of deleting the search tree representing $S_j \cap T$ for each of the other sets $S_j$ , where $n_T = |T|$ .

Remarks

If you expect only to implement a constant number of sets, then the above run-times reduce to:

initialization: $O(1)$
$O(\log n)$
$O(1)$
$O(\log n_T)$
$O(n_S)$

$n$ $n_T = |T|$ $T$

यदि आप अपेक्षा करते हैं $O(|V|)$ sets, where $V$ is your universe, you may need a different data structure if you want these operations to operate in sub-linear time. However, if you have pairs of sets whose intersection you know you will never test, you might be able to reduce the size of the index for the sets (by not including any sets whose intersection you will test) or use more than one registry (one for each collection of sets whose intersection you might test). In fact, a registry is only useful if you want centralized control of ensuring that each pair of sets has a record of each other in the index: it may be practical in some cases, at the initialization of a set $S$ , simply to record ad hoc each new set into the indices of the other sets $T$ whose intersection with $S$ you are interested in.

— Niel de Beaudrap
स्रोत

6

There are data structures that allow you to do this in less than linear time, even for worst-case inputs. See http://research.microsoft.com/pubs/173795/vldb11intersection.pdf (and the papers references in there).

If your two sets S and T have a large intersection and you have a dictionary for S, looking up elements of T in random order should quickly give you a common element. The most difficult case is when the intersection size is 0 or 1.

— Rasmus Pagh
स्रोत

3

Usually your programming language of choice will support a data structure with unique elements. In general there are three popular approaches: Trees, Hashes and Bitmasks. Tree elements must be comparable, Hash elements must be hashable and Bitmask elements must have some way of conversion to integers.

A tree-set will support insertion in O(log n) and intersection testing in Worst Case O(n log n).

A hash-set will support insertion in Amortized O(1*h) where 'h' is the running time of the hashing algorithm, and intersection test in Worst Case O(n).

Bitmask sets are not generally used like tree- and hash-sets.

— Karl Damgaard Asmussen
स्रोत

2

This would be a decent Stack Overflow answer, but here we'd like some detail on how and why it works.

— Raphael

3

If your case allows false positive answers, I'd use Bloom Filter with a single hash function.

You can implement it as follows :

Init an empty set

$B$ = bit array of $n$ bits, all set to 0.( $n$ should be chosen according to the number of possible elements)

Add an element to a set.

$B[hash(element)]=1$

Given two sets(B1,B2), report whether they intersect.

check if $B1$ $AND$ $B2$ $=$ $0$

Complexity

If $n$ is not too big, all operations are $O(1)$ .

— Grisha Weintraub
स्रोत