दिलचस्प पोस्ट
jQuery.ajax विफल रहता है जब यूआरएल अलग सर्वर से है जावा: एआरएम्स जैसे PHP के शामिल होने के लिए फ़ंक्शन ()? एनएटी क्षुधा के लिए लिंकर्स राज्य (उर्फ "कृपा करें, मुझे एक लिंकर मिला है" 2009 संस्करण) जावा: तिथि से महीना पूर्णांक प्राप्त करें मानदंड। DISTINCT_ROOT_ENTITY बनाम Projections.distinct कॉन्फ़िगरेशन पर उपयोग करने के तरीके () और नए कॉन्फ़िफ.औरेशन == कॉन्फ़िगरेशन। एंड्रॉइड 2.3.3 में कॉन्फ़िगरेशन। दो नंबरों का हैशोड बनाएं जावा अर्रे लिस्ट के लिए समय की जटिलता क्या प्रति पृष्ठ में ViewPager के कई दृश्य हो सकते हैं? जावा वेब अनुप्रयोग में एप्लिकेशन सर्वर के बाहर से स्थिर डेटा सेवा करने का सबसे सरल तरीका एचटीएमएल / सीएसएस: दो फ्लोटिंग डिवेल को समान ऊँचाई बनाना PHP में बाइनरी-सुरक्षित होने वाले फ़ंक्शन द्वारा इसका क्या अर्थ है? बहु परत perceptron (एमएलपी) वास्तुकला: छिपी परतों की संख्या और छिपी परत के आकार को चुनने के लिए मानदंड? जावा में एक प्रक्रिया को मारने के लिए, एक विशिष्ट पीआईडी ​​को दिए एक परियोजना में रेल नियंत्रक और मॉडल का नाम कैसे बदला जाए

क्या जावा सचमुच है ओ (1)?

मैंने कुछ दिलचस्प दावों को फिर से जावा हैशैप्स और उनके O(1) लुकअप समय पर देखा है। क्या कोई यह समझा सकता है कि ऐसा क्यों है? जब तक कि ये हैंशप्स किसी भी हिसिंग एल्गोरिदम से बहुत अलग हैं, जब तक मुझे खरीदा जाता था, तो हमेशा एक डेटासेट मौजूद होता है जिसमें टकराव होते हैं।

किस मामले में, O(1) बजाय लुकअप O(n) होगा

क्या कोई यह समझा सकता है कि क्या वे ओ (1) हैं, और यदि हां, तो वे इसे कैसे प्राप्त करते हैं?

Solutions Collecting From Web of "क्या जावा सचमुच है ओ (1)?"

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

पी टक्कर = एन / क्षमता

तो एक मामूली संख्या के साथ एक हश का नक्शा भी कम से कम एक टक्कर का अनुभव होने की संभावना है। बिग ओ नोटेशन हमें कुछ अधिक आकर्षक बनाने की अनुमति देता है निरीक्षण करें कि किसी भी मनमाना के लिए, स्थिर स्थिर k

ओ (एन) = हे (कश्मीर * एन)

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

पी टक्कर x 2 = (एन / क्षमता) 2

यह बहुत कम है चूंकि एक अतिरिक्त टक्कर से निपटने की लागत बिग हे प्रदर्शन के लिए अप्रासंगिक है, इसलिए हमने वास्तव में एल्गोरिदम बदलने के बिना प्रदर्शन में सुधार करने का एक तरीका पाया है! हम इसे सामान्य करने के लिए कर सकते हैं

पी टक्कर xk = (n / क्षमता) k

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

हम इस बारे में बात करते हुए कहते हैं कि हैश-मानचित्र में ओ (1) उच्च संभावना के साथ पहुंच है

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

किसी भी भरोसेमंद हैश तालिका कार्यान्वयन, एक अर्ध सभ्य हैश के साथ मिलकर, ओ (1) के एक बहुत छोटी कारक (2, वास्तव में) के पुनरुत्पादन के प्रदर्शन में, भिन्नता के एक बहुत ही संकीर्ण मार्जिन के भीतर, अपेक्षित मामले में है।

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

इसलिए, कभी-कभी इसे कुछ वस्तुओं के साथ तुलना करना पड़ता है, लेकिन आम तौर पर यह ओ (एन) की तुलना में ओ (1) के बहुत करीब है। व्यावहारिक प्रयोजनों के लिए, आपको यह जानने की आवश्यकता है।

याद रखें कि (1) इसका अर्थ यह नहीं है कि प्रत्येक लुकअप केवल एक आइटम की जांच करता है – इसका मतलब यह है कि चेक की गई वस्तुओं की औसत संख्या लगातार कंटेनर में वस्तुओं की संख्या लगातार बनी रहती है। इसलिए यदि यह 100 वस्तुओं के साथ एक कंटेनर में किसी आइटम को खोजने के लिए औसतन 4 तुलना लेता है, तो उसे एक कंटेनर में एक आइटम को 10000 वस्तुओं के साथ खोजने के लिए औसतन 4 तुलना लेनी चाहिए और किसी भी अन्य मदों के लिए भिन्नता का सा है, विशेषकर उन हदों के आस-पास जहां पर हैश तालिका की पुनरावृत्ति होती है, और जब बहुत छोटी वस्तुओं की संख्या होती है)।

इसलिए, टकराव कंटेनर को ओ (1) के संचालन से नहीं रोकता है, जब तक कि प्रति बाल्टी की औसत संख्या कुंजी निश्चित बांड में ही रहती है।

मुझे पता है यह एक पुराना सवाल है, लेकिन वास्तव में इसका एक नया जवाब है।

आप सही हैं कि एक हेश का नक्शा सचमुच O(1) , सख्ती से बोल रहा है, क्योंकि तत्वों की संख्या अनियमित रूप से बड़ी हो जाती है, अंत में आप निरंतर समय में खोज नहीं पाएंगे (और ओ-नोटेशन को परिभाषित किया गया है संख्याओं की संख्या जो मनमाने ढंग से बड़ी हो सकती है)।

लेकिन इसका पालन नहीं होता है कि वास्तविक समय की जटिलता O(n) क्योंकि ऐसा कोई नियम नहीं है कि बाल्टी को रैखिक सूची के रूप में लागू किया जाना है।

असल में, जावा 8 को TreeMaps रूप में बाल्टियों को लागू करता है, जब वे एक थ्रेशोल्ड से अधिक हो जाते हैं, जो वास्तविक समय O(log n) बनाता है।

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

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

O(1+n/k) जहां k बाल्टी की संख्या है

यदि कार्यान्वयन k = n/alpha तो यह O(1+alpha) = O(1) क्योंकि alpha एक स्थिरांक है

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

यह भी समझाया गया है कि कड़ाई से कहा जा रहा है कि किसी भी नियतात्मक हैश समारोह के लिए ओ ( एन ) लुकअप की आवश्यकता के लिए इनपुट का निर्माण संभव है। लेकिन यह सबसे ख़राब-मामला होने का अनुमान लगाया जाने वाला समय है, जो औसत खोज समय से अलग है। चेनिंग का उपयोग करना हे (1 + सबसे लंबी श्रृंखला की लंबाई) है, उदाहरण के लिए Θ (लॉग एन / लॉग लॉग एन ) जब α = 1

यदि आप सैद्धांतिक तरीके से रुचि रखते हैं, तो लगातार सबसे खराब केस देखने की संभावनाएं प्राप्त करने के लिए, आप डायनेमिक परिपूर्ण हैशिंग के बारे में पढ़ सकते हैं जो एक अन्य हैश तालिका के साथ फिर से टक्कर को हल करता है!

यह हे है (1) केवल अगर आपके हैशिंग फ़ंक्शन बहुत अच्छा है। जावा हैश तालिका कार्यान्वयन बुरा हैश फ़ंक्शंस के खिलाफ नहीं है।

चाहे आप तालिका को बढ़ने की आवश्यकता होती है जब आप आइटम जोड़ते हैं या नहीं प्रश्न के लिए प्रासंगिक नहीं है क्योंकि यह लुकअप समय के बारे में है

यह मूल रूप से अधिकांश प्रोग्रामिंग भाषाओं में सबसे हैश तालिका लागूकरण के लिए चला जाता है, क्योंकि एल्गोरिद्म स्वयं वास्तव में नहीं बदलता है

यदि टेबल में कोई टकराव मौजूद नहीं है, तो आपको केवल एक ही नज़र रखना होगा, इसलिए चलने का समय ओ (1) है। यदि टकराव मौजूद है, तो आपको एक से अधिक लुक-अप करना होगा, जो ओ (एन) की ओर प्रदर्शन को नीचे चलाता है।

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

एक व्यावहारिक दृष्टिकोण से अलग शैक्षणिक, हाशमैप्स को अप्रासंगिक प्रदर्शन प्रभाव के रूप में स्वीकार किया जाना चाहिए (जब तक कि आपके प्रोफाइलर अन्यथा आपको बताए।)

केवल सैद्धांतिक मामले में, जब हैशोड्स हमेशा अलग होते हैं और प्रत्येक हैश कोड के लिए बाल्टी भी अलग होती है, तो ओ (1) मौजूद होगा। अन्यथा, यह निरंतर आदेश का है अर्थात हिसप की वृद्धि, खोज का उसके क्रम स्थिर रहता है।

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

 location = (arraylength - 1) & keyhashcode 

यहां और बिटवर्ड और ऑपरेटर का प्रतिनिधित्व करता है।

उदाहरण के लिए: 100 & "ABC".hashCode() = 64 (location of the bucket for the key "ABC")

कार्रवाई के दौरान यह कुंजी के लिए बाल्टी के स्थान को निर्धारित करने के लिए समान तरीके से उपयोग करता है। सर्वोत्तम केस के तहत प्रत्येक हैशोड अद्वितीय है और प्रत्येक कुंजी के लिए एक अनूठे बाल्टी में परिणाम मिलता है, इस मामले में प्राप्त विधि केवल बाल्टी स्थान को निर्धारित करने और उस मूल्य को पुनः प्राप्त करने के लिए खर्च करती है जो लगातार O (1) है।

सबसे बुरी स्थिति के तहत, सभी कीज़ों में एक ही हैशोड होती है और एक ही बाल्टी में संग्रहीत होती है, यह परिणाम संपूर्ण सूची से गुजरती है जो ओ (एन) की ओर जाता है।

जावा 8 के मामले में, लिंक्ड लिस्ट बाल्टी को ट्रीमार्क के साथ बदल दिया जाता है यदि आकार 8 से अधिक तक बढ़ता है, तो यह ओ (लॉग एन) के लिए सबसे बुरी स्थिति की खोज क्षमता कम कर देता है।

हांमप का प्रदर्शन दिए गए ऑब्जेक्ट के लिए हैशोड () फ़ंक्शन की गुणवत्ता के आधार पर निर्भर करेगा। हालांकि, यदि फ़ंक्शन कार्यान्वित किया जाता है, तो इस तरह की टक्कर की संभावना बहुत कम है, इसमें बहुत अच्छा प्रदर्शन होगा (यह हर संभव मामले में कड़ाई से नहीं है (लेकिन यह ज्यादातर मामलों में है)।

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