डायनामिक परफेक्ट हैशिंग

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

विवरण

स्थैतिक मामला

एफकेएस योजना

Main article: स्टेटिक हैशिंग § एफकेएस हैशिंग

इष्टतम स्थैतिक हैशिंग की समस्या को सबसे पहले सामान्यतः फ्रेडमैन, कोमलोस और ज़ेमेरेडी द्वारा हल किया गया था। उनके 1984 के पेपर में,वे दो-स्तरीय हैश तालिका योजना का विवरण देते हैं जिसमें (प्रथम-स्तर) हैश तालिका की प्रत्येक बाल्टी अलग दूसरे-स्तरीय हैश तालिका से मेल खाती है। कुंजियाँ दो बार हैश की जाती हैं—पहला हैश मान प्रथम-स्तरीय हैश तालिका में निश्चित बकेट में मैप होता है; दूसरा हैश मान उस बकेट की दूसरी-स्तरीय हैश तालिका में उस प्रविष्टि की स्थिति बताता है। दूसरे स्तर की तालिका के निर्माण पर टकराव-मुक्त (यानी सही हैशिंग) होने की गारंटी है। नतीजतन, लुक-अप लागत बड़ा ओ अंकन|ओ(1) सबसे खराब स्थिति में जटिलता|सबसे खराब स्थिति में होने की गारंटी है।

स्थैतिक मामले में, हमें कुल के साथ सेट दिया जाता है x प्रविष्टियाँ, प्रत्येक अद्वितीय कुंजी के साथ, समय से पहले। फ़्रेडमैन, कोमलोस और ज़ेमेरेडी आकार के साथ प्रथम-स्तरीय हैश तालिका चुनते हैं $s=2(x-1)$ बाल्टियाँ।

निर्मित करना, x प्रविष्टियों को अलग किया गया है s शीर्ष-स्तरीय हैशिंग फ़ंक्शन द्वारा बकेट, जहां $s=2(x-1)$. फिर प्रत्येक बाल्टी के लिए k प्रविष्टियों के साथ, दूसरे स्तर की तालिका आवंटित की जाती है $k^{2}$ स्लॉट्स, और इसके हैश फंकशन को सार्वभौमिक हैश फ़ंक्शन सेट से यादृच्छिक रूप से चुना जाता है ताकि यह टकराव-मुक्त हो (यानी उत्तम हैश फ़ंक्शन) और हैश तालिका के साथ संग्रहीत हो। यदि यादृच्छिक रूप से यूनिवर्सल हैश फ़ंक्शन टकराव के साथ तालिका बनाता है, तो टकराव-मुक्त तालिका की गारंटी होने तक नया हैश फ़ंक्शन यादृच्छिक रूप से चुना जाता है। अंत में, टकराव-मुक्त हैश के साथ, k प्रविष्टियाँ दूसरे स्तर की तालिका में हैश की गई हैं।

का द्विघात आकार $k^{2}$ स्पेस यह सुनिश्चित करता है कि टकराव के साथ बेतरतीब ढंग से तालिका बनाना दुर्लभ और आकार से स्वतंत्र है k, रैखिक परिशोधन निर्माण समय प्रदान करना। हालाँकि प्रत्येक दूसरे स्तर की तालिका में द्विघात स्थान की आवश्यकता होती है, यदि प्रथम स्तर की हैश तालिका में डाली गई कुंजियाँ समान वितरण (अलग) हैं, तो समग्र रूप से संरचना अपेक्षित स्थान लेती है $O(n)$ स्थान, चूंकि बाल्टी का आकार छोटा है और इसकी संभावना अधिक है।

प्रथम-स्तरीय हैश फ़ंक्शन को विशेष रूप से चुना जाता है, ताकि विशिष्ट सेट के लिए x अद्वितीय कुंजी मान, कुल स्थान T सभी द्वितीय-स्तरीय हैश तालिकाओं द्वारा उपयोग अपेक्षित है $O(n)$ स्थान, और अधिक विशेष रूप से $T<s+4\cdot x$.फ्रेडमैन, कोमलोस और ज़ेमेरेडी ने दिखाया कि हैश फ़ंक्शंस के सार्वभौमिक हैशिंग परिवार को देखते हुए, उनमें से कम से कम आधे फ़ंक्शंस में वह संपत्ति होती है।

गतिशील मामला

डिट्ज़फेलबिंगर एट अल। गतिशील शब्दकोश एल्गोरिथ्म प्रस्तुत करें, जब n आइटमों का सेट शब्दकोष में क्रमिक रूप से जोड़ा जाता है, तो सदस्यता क्वेरी हमेशा निरंतर समय में चलती हैं और इसलिए $O(1)$ सबसे खराब स्थिति में, आवश्यक कुल भंडारण है $O(n)$ (रैखिक), और $O(1)$ अपेक्षित परिशोधन सम्मिलन और विलोपन समय (परिशोधन स्थिर समय)।

गतिशील मामले में, जब कुंजी को हैश तालिका में डाला जाता है, यदि उसके संबंधित उप-तालिका में उसकी प्रविष्टि पर कब्जा कर लिया जाता है, तो टकराव होता है और उप-तालिका को उसकी नई कुल प्रविष्टि गणना और यादृच्छिक रूप से चयनित हैश फ़ंक्शन के आधार पर फिर से बनाया जाता है। क्योंकि द्वितीय स्तर की तालिका का लोड फैक्टर (हैश तालिका) कम रखा जाता है $1/k$, पुनर्निर्माण दुर्लभ है, और परिशोधन विश्लेषण सम्मिलन की अपेक्षित लागत है $O(1)$.इसी प्रकार, विलोपन की परिशोधित अपेक्षित लागत है $O(1)$.

इसके अतिरिक्त, गतिशील मामले में शीर्ष-स्तरीय तालिका या किसी उप-सारणी का अंतिम आकार अज्ञात है। उम्मीद बनाए रखने का तरीका $O(n)$ पर्याप्त संख्या में सम्मिलन और विलोपन होने पर तालिका का स्थान पूर्ण पुनर्निर्माण का संकेत देता है। डाइट्ज़फेलबिंगर एट अल के परिणामों के आधार पर,जब तक सम्मिलन या विलोपन की कुल संख्या पिछले निर्माण के समय तत्वों की संख्या से अधिक हो जाती है, तब तक सम्मिलन और विलोपन की परिशोधित अपेक्षित लागत बनी रहती है $O(1)$ पूरी पुनर्रचना को ध्यान में रखते हुए।

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

स्यूडोकोड कार्यान्वयन

पता लगाएँ

function Locate(x) is
    j := h(x)
     if (position hj(x) of subtable Tj contains x (not deleted))
        return (x is in S)
     end if
     else 
        return (x is not in S)
   end else
end

सम्मिलित करें

j पर नई प्रविष्टि x को सम्मिलित करने के दौरान, वैश्विक संचालन काउंटर, गिनती, बढ़ जाती है।

यदि x, j पर मौजूद है, लेकिन हटाए गए के रूप में चिह्नित है, तो निशान हटा दिया जाता है।

यदि x, j या उपसारणी T पर मौजूद है_j, और हटाए गए के रूप में चिह्नित नहीं किया गया है, तो कहा जाता है कि टकराव होता है और जे^वेंबकेट की दूसरी-स्तरीय तालिका टी_j अलग यादृच्छिक रूप से चयनित हैश फ़ंक्शन एच के साथ फिर से बनाया गया है_j.

function Insert(x) is
   count = count + 1;
     if (count > M) 
         FullRehash(x);
     end if
    else
        j = h(x);
        if (Position hj(x) of subtable Tj contains x)
            if (x is marked deleted) 
                remove the delete marker;
            end if
        end if
          else
            bj = bj + 1;
            if (bj <= mj) 
                if position hj(x) of Tj is empty 
                    store x in position hj(x) of Tj;
                end if
                else
                     Put all unmarked elements of Tj in list Lj;
                    Append x to list Lj;
                     bj = length of Lj;
                    repeat 
                        hj = randomly chosen function in Hsj;
                    until hj is injective on the elements of Lj;
                    for all y on list Lj
                    store y in position hj(y) of Tj;
                end for
            end else
             end if else
                mj = 2 * max{1, mj};
                sj = 2 * mj * (mj - 1);
                if the sum total of all sj ≤ 32 * M2 / s(M) + 4 * M 
                    Allocate sj cells for Tj;
                     Put all unmarked elements of Tj in list Lj;
                    Append x to list Lj;
                    bj = length of Lj;
                    repeat 
                        hj = randomly chosen function in Hsj;
                    until hj is injective on the elements of Lj;
                    for all y on list Lj
                    store y in position hj(y) of Tj;
                 end for
                end if

                 else
                    FullRehash(x);
                end else
             end else
        end else
     end else
end

हटाएं

x का विलोपन केवल x को हटाए बिना और वेतन वृद्धि की गिनती के रूप में चिह्नित करता है। सम्मिलन और विलोपन दोनों के मामले में, यदि गिनती सीमा एम तक पहुंचती है तो पूरी तालिका फिर से बनाई जाती है, जहां एम नए चरण की शुरुआत में एस के आकार का कुछ स्थिर गुणक है। यहां चरण का तात्पर्य पूर्ण पुनर्निर्माण के बीच के समय से है। ध्यान दें कि यहां Delete(x) में -1 ऐसे तत्व का प्रतिनिधित्व है जो सभी संभावित तत्वों U के सेट में नहीं है।

function Delete(x) is
   count = count + 1;

     j = h(x);
    if position hj(x) of subtable Tj contains x
        mark x as deleted;
    end if
    else 
        return (x is not a member of S);
    end else
    if (count >= M)
        FullRehash(-1);
   end if
end

पूर्ण पुनर्निर्माण

S की तालिका का पूर्ण पुनर्निर्माण सबसे पहले हटाए गए के रूप में चिह्नित सभी तत्वों को हटाकर शुरू होता है और फिर अगले थ्रेशोल्ड मान M को S के आकार के कुछ स्थिर गुणक पर सेट करता है। हैश फ़ंक्शन, जो S को s(M) उपसमुच्चय में विभाजित करता है, जहां उपसमुच्चय j का आकार s है_j, बार-बार यादृच्छिक रूप से तब तक चुना जाता है जब तक:

$\sum _{0\leq j\leq s(M)}s_{j}\leq {\frac {32M^{2}}{s(M)}}+4M.$ अंत में, प्रत्येक उपसारणी टी के लिए_j हैश फ़ंक्शन एच_jH से बार-बार यादृच्छिक रूप से चुना जाता है_sjजब तक एच_jटी के तत्वों पर विशेषण है_j. आकार n के साथ S की तालिका के पूर्ण पुनर्निर्माण के लिए अपेक्षित समय O(n) है।

फ़ंक्शन FullRehash(x) है

    function FullRehash(x) is
    Put all unmarked elements of T in list L;
        if (x is in U) 
    append x to L;
    end if
     count = length of list L;
    M = (1 + c) * max{count, 4};
        repeat 
        h = randomly chosen function in Hs(M);
             for all j < s(M) 
            form a list Lj for h(x) = j;
             bj = length of Lj; 
           mj = 2 * bj; 
        sj = 2 * mj * (mj - 1);
     end for
    until the sum total of all sj ≤ 32 * M2 / s(M) + 4 * M
        for all j < s(M) 
        Allocate space sj for subtable Tj;
             repeat 
         hj = randomly chosen function in Hsj;
    until hj is injective on the elements of list Lj;
    end for
    for all x on list Lj 
store x in position hj(x) of Tj;

end for

end

यह भी देखें

• उत्तम हैशिंग