जावा कलेक्शन फ्रेमवर्क कार्यान्वयन के लिए बिग-ओ सारांश? [बन्द है]

Question

मैं जल्द ही "जावा क्रैश-कोर्स" सिखा सकता हूं। हालांकि यह मान लेना सुरक्षित है कि दर्शकों के सदस्यों को बिग-ओ नोटेशन पता चल जाएगा, यह मान लेना सुरक्षित नहीं है कि उन्हें पता चल जाएगा कि विभिन्न संग्रह कार्यान्वयन पर विभिन्न कार्यों का क्रम क्या है।

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

किसी के पास कोई संकेत है?

Comments

यहाँ कुछ उपयोगी सामान्य जावा वस्तुओं और बिग-ओ नोटेशन का उपयोग करते हुए उनके संचालन की लागत पर चर्चा करते समय एक लिंक पाया गया है। objectissues.blogspot.com/2006/11/…

— निक

हालांकि सार्वजनिक डोमेन में नहीं है, मौरिस नाफ्टलिन और फिलिप वाडलर द्वारा उत्कृष्ट जावा जेनेरिक एंड कलेक्शंस विभिन्न चैप्टर क्लासेस पर इसके अध्यायों में रनटाइम सूचनाओं को सूचीबद्ध करता है।

— फैबियन स्टील

क्या यह प्रदर्शन बेंचमार्क किसी काम का होगा?

— थ्रोट

Answer 1

यह वेबसाइट बहुत अच्छी है लेकिन जावा के लिए विशिष्ट नहीं है: http://bigocheatsheet.com/

Comments

और यही कारण है कि हम उत्तर के रूप में URL का उपयोग नहीं करते हैं। वह दस्तावेज़ / सर्वर, जहाँ तक मैं बता सकता हूँ, अब उपलब्ध नहीं है!

— जेसन मॉक

@ जेन जे लिंक्स अब अधिक काम नहीं कर रहे हैं

— विकास वी।

वेब आर्काइव लिंक अब टूट भी गए हैं।

— मीकफ़ेह

नए काम करने वाले URL जोड़े गए। प्रयास करने के लिए धन्यवाद, यह बहुत मददगार है।

— तेजस C

@AndreaZilio LinkedList.remove (ऑब्जेक्ट) निरंतर समय है, यह मानते हुए कि आप पहले से ही पड़ोसी को जानते हैं। यदि आप पड़ोसी को नहीं जानते हैं, तो पहले इसे खोजने के लिए रैखिक समय है।

— पॉल इवान्स

Answer 2

जावा जेनरिक एंड कलेक्शंस की किताब में यह जानकारी है (पृष्ठ: 188, 211, 222, 240)।

सूची कार्यान्वयन:

                      get  add  contains next remove(0) iterator.remove
ArrayList             O(1) O(1) O(n)     O(1) O(n)      O(n)
LinkedList            O(n) O(1) O(n)     O(1) O(1)      O(1)
CopyOnWrite-ArrayList O(1) O(n) O(n)     O(1) O(n)      O(n)

कार्यान्वयन सेट करें:

                      add      contains next     notes
HashSet               O(1)     O(1)     O(h/n)   h is the table capacity
LinkedHashSet         O(1)     O(1)     O(1) 
CopyOnWriteArraySet   O(n)     O(n)     O(1) 
EnumSet               O(1)     O(1)     O(1) 
TreeSet               O(log n) O(log n) O(log n)
ConcurrentSkipListSet O(log n) O(log n) O(1)

मानचित्र कार्यान्वयन:

                      get      containsKey next     Notes
HashMap               O(1)     O(1)        O(h/n)   h is the table capacity
LinkedHashMap         O(1)     O(1)        O(1) 
IdentityHashMap       O(1)     O(1)        O(h/n)   h is the table capacity 
EnumMap               O(1)     O(1)        O(1) 
TreeMap               O(log n) O(log n)    O(log n) 
ConcurrentHashMap     O(1)     O(1)        O(h/n)   h is the table capacity 
ConcurrentSkipListMap O(log n) O(log n)    O(1)

कतार कार्यान्वयन:

                      offer    peek poll     size
PriorityQueue         O(log n) O(1) O(log n) O(1)
ConcurrentLinkedQueue O(1)     O(1) O(1)     O(n)
ArrayBlockingQueue    O(1)     O(1) O(1)     O(1)
LinkedBlockingQueue   O(1)     O(1) O(1)     O(1)
PriorityBlockingQueue O(log n) O(1) O(log n) O(1)
DelayQueue            O(log n) O(1) O(log n) O(1)
LinkedList            O(1)     O(1) O(1)     O(1)
ArrayDeque            O(1)     O(1) O(1)     O(1)
LinkedBlockingDeque   O(1)     O(1) O(1)     O(1)

Java.util पैकेज के लिए javadoc के नीचे कुछ अच्छे लिंक होते हैं:

• संग्रह अवलोकन में एक अच्छी सारांश तालिका है।
• एनोटेट की रूपरेखा एक पृष्ठ पर सभी कार्यान्वयन को सूचीबद्ध करती है।

Comments

आपको निर्दिष्ट करना होगा कि कौन से मामले का परिदृश्य वे आंकड़े हैं, उदाहरण के लिए, Arraylist से हटाएं O (n) ले सकते हैं, यदि आप सरणी के मध्य या अंत में तत्व हटाते हैं।

— Popeye

@ Popeye O आमतौर पर सबसे खराब स्थिति नहीं है?

— यिसन हज

जैसा कि @Popeye द्वारा उल्लेख किया गया है, इस बारे में स्पष्ट विवरण होना चाहिए कि उत्तर किस बारे में है। मामला समय की जटिलता के लिए या तो औसत / सबसे खराब हो सकता है। ऐसा लगता है कि उत्तर सभी डीएस के लिए "औसत" मामले का उल्लेख कर रहा है।

— यशविन मुंसदवाला

Answer 3

प्रत्येक संग्रह वर्ग के लिए सूर्य से Javadocs आम तौर पर आपको वही बताएंगे जो आप चाहते हैं। उदाहरण के लिए, HashMap :

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

ट्रीपैप :

इस कार्यान्वयन में शामिल हैं के लिए गारंटीकृत लॉग (n) समय लागत प्रदान करता है, संचालन प्राप्त करें, डालें और निकालें।

ट्रीसेट :

यह कार्यान्वयन मूल संचालन (जोड़ें, निकालें और शामिल) के लिए गारंटीकृत लॉग (एन) समय लागत प्रदान करता है ।

(जोर मेरा)

Comments

मैं HashMap भाग से असहमत हूं। मुझे पता है कि सूर्य की स्थिति, लेकिन ... उदाहरण के लिए obj.equals (कुंजी) को कॉल करें, जो निहित वस्तुओं के आकार में रैखिक हो सकता है। इस बात पर विचार करें कि आमतौर पर आपको इस तुलना के लिए फ़ील्ड पढ़ना होगा। अपवाद पूर्णांक या तार (इंटर्न) होंगे ???

— ओवरफ्लो

सबसे पहले, अगर वे गलत थे, तो आपके लिए एक परीक्षण मामला बनाने के लिए बहुत मुश्किल नहीं होना चाहिए जो निरंतर-समय के प्रदर्शन को बाधित करता है? दूसरा, यदि आप HashMap के लिए स्रोत कोड को देखते हैं, तो यह मानचित्र में प्रत्येक कुंजी के खिलाफ बराबर () कॉल नहीं करता है - केवल जब हैशकोड समान होते हैं।

— मैट बी

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

— newacct

@Overflown - तकनीकी रूप से, इससे कोई फर्क नहीं पड़ता कि जटिलता के परिप्रेक्ष्य से कितनी लंबी obj.equals () लगती है, क्योंकि यह संग्रह में मदों की संख्या के संबंध में "निरंतर" का सिर्फ एक हिस्सा है।

— mikera

Answer 4

ऊपर दिए गए लड़के ने HashMap / HashSet बनाम TreeMap / TreeSet की तुलना की।

मैं ArrayList बनाम LinkedList के बारे में बात करूंगा:

सारणी सूची:

• हे (1) get()
• परिशोधन O (1) add()
• यदि आप बीच में किसी तत्व को सम्मिलित करते हैं ListIterator.add()या उपयोग करते हैं या हटाते हैं Iterator.remove(), तो निम्नलिखित सभी तत्वों को स्थानांतरित करना O (n) होगा

लिंक्ड सूची:

• पर) get()
• हे (1) add()
• यदि आप डालने या का उपयोग करते हुए बीच में एक तत्व को नष्ट ListIterator.add()या Iterator.remove(), यह हो जाएगा हे (1)

Comments

if you insert or delete an element in the middle using ListIterator.add() or Iterator.remove(), it will be O(1) क्यों? पहले हमें बीच में तत्व खोजने की जरूरत है, इसलिए यह ओ (एन) क्यों नहीं?

— MyTitle

@MyTitle: इसे फिर से पढ़ें। "का उपयोग करना ListIterator.add()या Iterator.remove()" हमारे पास एक पुनरावृत्ति है।

— newacct