मैंने हमेशा पेड़ों से प्यार किया है, यह अच्छा है O(n*log(n))और उनकी ख़ुशी। हालाँकि, मेरे द्वारा ज्ञात प्रत्येक सॉफ़्टवेयर इंजीनियर ने मुझसे स्पष्ट रूप से पूछा है कि मैं एक का उपयोग क्यों करूंगा TreeSet। एक CS बैकग्राउंड से, मुझे नहीं लगता कि यह सब बहुत मायने रखता है जो आप उपयोग करते हैं, और मुझे हैश फ़ंक्शंस और बकेट्स (मामले में Java) के साथ गड़बड़ करने की परवाह नहीं है ।
किन मामलों में मुझे एक HashSetसे अधिक का उपयोग करना चाहिए TreeSet?
जवाबों:
हैशसेट ट्रीसेट (ऐड, रिमूव और सम्मिलित जैसे अधिकांश परिचालनों के लिए निरंतर-समय बनाम लॉग-टाइम) की तुलना में बहुत तेज़ है, लेकिन ट्रीसेट जैसी कोई आदेश गारंटी नहीं देता है।
SortedSet)first(), last(), headSet(), और tailSet()आदिHashSetऔर TreeSet। एक हैश तालिका के रूप में कार्यान्वित एक लिंक की गई सूची के माध्यम से चल रहा है, हालांकि, यह प्रविष्टि-आदेशित पुनरावृत्ति प्रदान करता है जो ट्रीसेट द्वारा गारंटीकृत ट्रैवर्सल के समान नहीं है ।इसलिए उपयोग का एक विकल्प पूरी तरह से आपकी आवश्यकताओं पर निर्भर करता है लेकिन मुझे लगता है कि अगर आपको एक ऑर्डर किए गए संग्रह की आवश्यकता है, तो भी आपको सेट बनाने के लिए हैशसेट पसंद करना चाहिए और फिर ट्रीसेट में परिवर्तित करना चाहिए।
SortedSet<String> s = new TreeSet<String>(hashSet);एक लाभ का अभी तक उल्लेख नहीं किया गया TreeSetहै कि इसकी अधिक "स्थानीयता" है, जो कहने के लिए शॉर्टहैंड है (1) यदि दो प्रविष्टियां क्रम में पास हैं, TreeSetतो डेटा संरचना में उन्हें एक दूसरे के पास रखता है, और इसलिए स्मृति में; और (2) यह प्लेसमेंट स्थानीयता के सिद्धांत का लाभ उठाता है, जो कहता है कि समान आवृत्ति वाले एप्लिकेशन द्वारा समान डेटा अक्सर एक्सेस किया जाता है।
यह एक के विपरीत है HashSet, जो सभी मेमोरी में प्रविष्टियों को फैलाता है, चाहे उनकी कुंजी कोई भी हो।
जब हार्ड ड्राइव से पढ़ने की विलंबता लागत कैश या रैम से पढ़ने की लागत का हजारों गुना होती है, और जब डेटा को वास्तव में स्थानीयता के साथ एक्सेस किया जाता है, तो TreeSetयह एक बेहतर विकल्प हो सकता है।
TreeSet/ TreeMapस्थानीयता अनुकूलित नहीं है। हालांकि लाल-काले पेड़ का प्रतिनिधित्व करने के लिए आदेश 4 के बी-ट्री का उपयोग करना संभव है और इस प्रकार स्थानीयता और कैश प्रदर्शन में सुधार होता है, यही नहीं कार्यान्वयन कैसे काम करता है। इसके बजाय, प्रत्येक नोड अपने स्वयं के कुंजी, अपने स्वयं के मूल्य, अपने माता-पिता और अपने बाएं और दाएं बच्चे के नोड्स के लिए एक पॉइंटर को स्टोर करता है, जो कि TreeMap.Entry के लिए JDK 8 स्रोत कोड में स्पष्ट है ।
HashSetतत्वों तक पहुँचने के लिए O (1) है, इसलिए यह निश्चित रूप से मायने रखता है। लेकिन सेट में वस्तुओं का क्रम बनाए रखना संभव नहीं है।
TreeSetयदि कोई आदेश बनाए रखना उपयोगी है (मूल्यों के संदर्भ में और प्रविष्टि आदेश नहीं) तो आपके लिए मायने रखता है। लेकिन, जैसा कि आपने नोट किया है, आप बुनियादी कार्यों के लिए एक तत्व: ओ (लॉग एन) का उपयोग करने के लिए धीमे समय के लिए ट्रेडिंग ऑर्डर कर रहे हैं।
के लिए javadocs सेTreeSet :
इस कार्यान्वयन बुनियादी कार्यों के लिए गारंटी लॉग (एन) समय लागत प्रदान करता है (
add,removeऔरcontains)।
1. हाशसेट शून्य वस्तु की अनुमति देता है।
2.TreeSet अशक्त वस्तु की अनुमति नहीं देगा। यदि आप अशक्त मान जोड़ने का प्रयास करते हैं तो यह NullPointerException को फेंक देगा।
3.HashSet ट्रीसेट की तुलना में बहुत तेज है।
जैसे
TreeSet<String> ts = new TreeSet<String>();
ts.add(null); // throws NullPointerException
HashSet<String> hs = new HashSet<String>();
hs.add(null); // runs finenullकिसी भी तरह से अपने सेट से नहीं जोड़ना चाहिए ।
TreeSet<String> badassTreeSet = new TreeSet<String>(new Comparator<String>() { public int compare(String string1, String string2) { if (string1 == null) { return (string2 == null) ? 0 : -1; } else if (string2 == null) { return 1; } else { return string1.compareTo(string2); } } }); badassTreeSet.add("tree"); badassTreeSet.add("asdf"); badassTreeSet.add(null); badassTreeSet.add(null); badassTreeSet.add("set"); badassTreeSet.add("tree"); System.out.println(badassTreeSet);
यहाँ पर @shevchyk द्वारा मानचित्रों पर सुंदर दृश्य उत्तर देने पर मेरा विचार है:
╔══════════════╦═════════════════════╦═══════════════════╦═════════════════════╗
║ Property ║ HashSet ║ TreeSet ║ LinkedHashSet ║
╠══════════════╬═════════════════════╬═══════════════════╬═════════════════════╣
║ ║ no guarantee order ║ sorted according ║ ║
║ Order ║ will remain constant║ to the natural ║ insertion-order ║
║ ║ over time ║ ordering ║ ║
╠══════════════╬═════════════════════╬═══════════════════╬═════════════════════╣
║ Add/remove ║ O(1) ║ O(log(n)) ║ O(1) ║
╠══════════════╬═════════════════════╬═══════════════════╬═════════════════════╣
║ ║ ║ NavigableSet ║ ║
║ Interfaces ║ Set ║ Set ║ Set ║
║ ║ ║ SortedSet ║ ║
╠══════════════╬═════════════════════╬═══════════════════╬═════════════════════╣
║ ║ ║ not allowed ║ ║
║ Null values ║ allowed ║ 1st element only ║ allowed ║
║ ║ ║ in Java 7 ║ ║
╠══════════════╬═════════════════════╩═══════════════════╩═════════════════════╣
║ ║ Fail-fast behavior of an iterator cannot be guaranteed ║
║ Fail-fast ║ impossible to make any hard guarantees in the presence of ║
║ behavior ║ unsynchronized concurrent modification ║
╠══════════════╬═══════════════════════════════════════════════════════════════╣
║ Is ║ ║
║ synchronized ║ implementation is not synchronized ║
╚══════════════╩═══════════════════════════════════════════════════════════════╝सबसे अधिक उपयोग करने का कारण यह HashSetहै कि संचालन ओ (लॉग एन) के बजाय ओ (1) औसत हैं। यदि सेट में मानक आइटम हैं, तो आप "हैश फ़ंक्शन के साथ खिलवाड़ नहीं करेंगे" जैसा कि आपके लिए किया गया है। यदि सेट में कस्टम कक्षाएं हैं, तो आपको hashCodeउपयोग करने के लिए लागू करना होगा HashSet(हालांकि प्रभावी जावा दिखाता है कि कैसे), लेकिन यदि आप उपयोग करते TreeSetहैं तो आपको इसे बनाना होगा Comparableया आपूर्ति करना होगा Comparator। यह एक समस्या हो सकती है यदि वर्ग के पास कोई विशेष आदेश नहीं है।
मैंने कभी-कभी उपयोग किया है TreeSet(या वास्तव मेंTreeMap बहुत छोटे सेट / नक्शे (<10 आइटम) के लिए ) का हालांकि मैंने यह देखने के लिए जांच नहीं की है कि ऐसा करने में कोई वास्तविक लाभ है या नहीं। बड़े सेटों के लिए अंतर काफी हो सकता है।
अब यदि आपको छांटे जाने की आवश्यकता है, तो TreeSetउचित है, हालांकि तब भी जब अद्यतन लगातार होते हैं और एक हल किए गए परिणाम की आवश्यकता होती है, तो कभी-कभी सामग्री को किसी सूची या सरणी में कॉपी करना और उन्हें क्रमबद्ध करना तेजी से हो सकता है।
यदि आप लगातार रिहर्सिंग (या टकराव, यदि आपका हैशटेट का आकार परिवर्तन नहीं कर सकते हैं) में परिणाम के लिए पर्याप्त तत्व नहीं डाल रहे हैं, तो निश्चित रूप से आपको निरंतर समय के उपयोग का लाभ देता है। लेकिन बहुत सारे विकास या सिकुड़न के साथ सेट पर, कार्यान्वयन के आधार पर आपको वास्तव में ट्रीसेट के साथ बेहतर प्रदर्शन मिल सकता है।
यदि स्मृति मेरी सेवा करती है, तो परिचालित समय O (1) के करीब हो सकता है। ओकासाकी की किताब में एक बेहतर व्याख्या होगी जो मैं खींच सकता हूं। (या उनकी प्रकाशन सूची देखें )
हैशसेट कार्यान्वयन निश्चित रूप से बहुत तेजी से कम ओवरहेड हैं क्योंकि कोई आदेश नहीं है। जावा में विभिन्न सेट कार्यान्वयन का एक अच्छा विश्लेषण http://java.sun.com/docs/books/tutorial/collections/implementations/set.html पर प्रदान किया गया है ।
वहां की चर्चा ट्री बनाम हैश प्रश्न के लिए एक दिलचस्प 'मध्यम आधार' दृष्टिकोण को भी इंगित करती है। Java एक LinkedHashSet प्रदान करता है, जो कि एक "सम्मिलन-उन्मुख" लिंक्ड सूची है, जो इसके माध्यम से चल रही है, यानी, लिंक की गई सूची में अंतिम तत्व भी हाल ही में हैश में डाला गया है। यह आपको किसी ट्रीसेट की बढ़ी हुई लागत के बिना एक अनियंत्रित हैश की अनियंत्रितता से बचने की अनुमति देता है।
TreeSet दो क्रमबद्ध संग्रह (दूसरे अभिनेता ट्री-मैप) में से एक है। यह एक रेड-ब्लैक ट्री संरचना का उपयोग करता है (लेकिन आप जानते थे कि), और गारंटी देता है कि तत्व प्राकृतिक क्रम के अनुसार आरोही क्रम में होंगे। वैकल्पिक रूप से, आप एक ऐसे कंस्ट्रक्टर के साथ ट्रीसेट का निर्माण कर सकते हैं, जो आपको एक तुलनीय या तुलनात्मक का उपयोग करके आदेश (जो तत्वों के वर्ग द्वारा परिभाषित आदेश पर निर्भर होने के बजाय) होना चाहिए, के लिए अपने स्वयं के नियम देता है।
और A LinkedHashSet , HashSet का एक ऑर्डर किया गया संस्करण है, जो सभी तत्वों में एक डबल -लिंक्ड सूची रखता है। जब आप पुनरावृति क्रम की परवाह करते हैं, तो हैशसेट के बजाय इस वर्ग का उपयोग करें। जब आप किसी HashSet के माध्यम से पुनरावृति करते हैं, तो आदेश अप्रत्याशित होता है, जबकि एक LinkedHashSet आपको उस क्रम में तत्वों के माध्यम से पुनरावृत्त करने देता है जिसमें वे सम्मिलित किए गए थे
तकनीकी विचारों, विशेष रूप से प्रदर्शन के आधार पर, बहुत सारे उत्तर दिए गए हैं। मेरे अनुसार, चुनाव TreeSetऔर HashSetमामलों के बीच का चुनाव ।
लेकिन मैं कहूंगा कि चुनाव को पहले वैचारिक विचारों से प्रेरित होना चाहिए ।
यदि, वस्तुओं के लिए आपकी हेरफेर करने की आवश्यकता है, तो एक प्राकृतिक आदेश का कोई मतलब नहीं है, फिर उपयोग न करें TreeSet।
यह एक क्रमबद्ध सेट है, क्योंकि यह लागू होता है SortedSet। तो इसका मतलब है कि आपको फ़ंक्शन को ओवरराइड करने की आवश्यकता होगी 0 न केवल तब जब दो ऑब्जेक्ट एक ही छात्र का प्रतिनिधित्व करेंगे, बल्कि यह भी कि जब दो अलग-अलग छात्रों के पास एक ही ग्रेड है। दूसरे मामले के लिए,compareTo , जो कि रिटर्न फ़ंक्शन के अनुरूप होना चाहिए , क्योंकि छात्रों के बीच कोई प्राकृतिक आदेश नहीं है। आप उन्हें उनके औसत ग्रेड द्वारा ऑर्डर कर सकते हैं, ठीक है, लेकिन यह "प्राकृतिक ऑर्डरिंग" नहीं है। समारोहequals । उदाहरण के लिए यदि आपके पास छात्र नामक कक्षा की वस्तुओं का एक सेट है, तो मुझे नहीं लगता कि एTreeSetcompareToequalsगलत हो जाएगा (जब तक कि आप बाद के रिटर्न को सच करने का निर्णय नहीं लेते हैं जब दो अलग-अलग छात्रों के पास एक ही ग्रेड होता है, जो equalsफ़ंक्शन को एक भ्रामक अर्थ देगा, गलत अर्थ कहने के लिए नहीं।)
कृपया इस निरंतरता के बीच ध्यान दें equalsऔर compareToवैकल्पिक है, लेकिन दृढ़ता से। की सिफारिश की। अन्यथा इंटरफ़ेस का अनुबंधSet का टूट गया है, जिससे आपका कोड अन्य लोगों को गुमराह कर रहा है, इस प्रकार संभवतः अप्रत्याशित व्यवहार भी हो सकता है।
यह लिंक इस प्रश्न के बारे में जानकारी का एक अच्छा स्रोत हो सकता है।
जब आपके पास संतरे हो सकते हैं तो सेब क्यों है?
गंभीरता से दोस्तों और लड़कियों - यदि आपका संग्रह बड़ा है, पढ़ा है और समय के गजलों के लिए लिखा गया है, और आप सीपीयू चक्रों के लिए भुगतान कर रहे हैं, तो संग्रह का विकल्प केवल तभी प्रासंगिक है जब आप इसे बेहतर प्रदर्शन करने के लिए चाहते हैं। हालांकि, ज्यादातर मामलों में, यह वास्तव में मायने नहीं रखता है - कुछ मिलीसेकंड यहां और वहां मानवीय संदर्भों में किसी का ध्यान नहीं जाता है। यदि यह वास्तव में बहुत मायने रखता है, तो आप कोडांतरक या सी में कोड क्यों नहीं लिख रहे हैं? [क्यू एक और चर्चा]। तो बात यह है कि यदि आपने जो भी संग्रह चुना है, उसका उपयोग करके आप खुश हैं, और यह आपकी समस्या को हल करता है [भले ही यह विशेष रूप से कार्य के लिए सबसे अच्छा प्रकार का संग्रह नहीं है] खुद को बाहर निकालें। सॉफ्टवेयर निंदनीय है। अपना कोड ऑप्टिमाइज़ करें जहाँ आवश्यक हो। अंकल बॉब का कहना है कि प्रीमेच्योर ऑप्टिमाइज़ेशन सभी बुराई की जड़ है। चाचा बॉब ऐसा कहते हैं
संदेश संपादित करें ( पूर्ण पुनर्लेखन ) जब आदेश कोई मायने नहीं रखता है, तो वह है। दोनों को लॉग (n) देना चाहिए - यह देखने के लिए उपयोगी होगा कि क्या या तो अन्य की तुलना में पांच प्रतिशत अधिक तेज है। हैशसेट एक लूप में O (1) परीक्षण दे सकता है कि क्या यह पता चलता है।
import java.util.HashSet;
import java.util.Set;
import java.util.TreeSet;
public class HashTreeSetCompare {
//It is generally faster to add elements to the HashSet and then
//convert the collection to a TreeSet for a duplicate-free sorted
//Traversal.
//really?
O(Hash + tree set) > O(tree set) ??
Really???? Why?
public static void main(String args[]) {
int size = 80000;
useHashThenTreeSet(size);
useTreeSetOnly(size);
}
private static void useTreeSetOnly(int size) {
System.out.println("useTreeSetOnly: ");
long start = System.currentTimeMillis();
Set<String> sortedSet = new TreeSet<String>();
for (int i = 0; i < size; i++) {
sortedSet.add(i + "");
}
//System.out.println(sortedSet);
long end = System.currentTimeMillis();
System.out.println("useTreeSetOnly: " + (end - start));
}
private static void useHashThenTreeSet(int size) {
System.out.println("useHashThenTreeSet: ");
long start = System.currentTimeMillis();
Set<String> set = new HashSet<String>();
for (int i = 0; i < size; i++) {
set.add(i + "");
}
Set<String> sortedSet = new TreeSet<String>(set);
//System.out.println(sortedSet);
long end = System.currentTimeMillis();
System.out.println("useHashThenTreeSet: " + (end - start));
}
}