दिलचस्प पोस्ट
फॉर्म रीरेंडर के बाद जावास्क्रिप्ट फ़ंक्शन को फिर से कैसे कार्यान्वित करें? पायथन 3.x में एक सूची वापस करने के लिए मानचित्र () प्राप्त करना मेरी iPhone ऐप में तिथि करने के लिए स्ट्रिंग कन्वर्ट रूट के रूप में NSTask का उपयोग कैसे करें? क्लास.नईवंस्टेंस () "बुराई" क्यों है? स्विफ्ट में ऑब्जेक्ट क्लास एट्रिब्यूट्स पर पुनरावृत्त करें बाश स्क्रिप्ट के पास दिए गए तर्कों की संख्या की जांच करें कोड :: ब्लॉक आईडीई के लिए स्थिर libcurl जोड़ना सी # में स्थैतिक चर का उपयोग क्या है? इसे कब उपयोग करना है? मैं विधि के भीतर स्थिर वैरिएबल क्यों नहीं घोषित कर सकता हूं? एकल पंक्ति के लिए edittext प्रतिबंधित करें asp.net mvc एक अलग परियोजना में नियंत्रकों रखा पायथन कक्षाओं में समानता ("समानता") का समर्थन करने के लिए शानदार तरीके मुझे अंतरफलक और एक सार वर्ग के बीच अंतर कैसे समझाया जाना चाहिए? डेटा के एक समूह के बाद स्वतः रिक्त पंक्ति कैसे डालें सही जावास्क्रिप्ट विरासत

जावा में क्रमबद्ध संग्रह

मैं जावा में एक शुरुआत कर रहा हूँ कृपया सुझाव दें कि जावा में सॉर्ट की गई सूची को बनाए रखने के लिए कौन से संग्रह (कों) का उपयोग किया जा सकता है? मैंने Map और Set की कोशिश की है, लेकिन वे नहीं थे जो मैं देख रहा था।

Solutions Collecting From Web of "जावा में क्रमबद्ध संग्रह"

यह बहुत देर हो चुकी है, लेकिन एक क्रमबद्ध सूची बनाने के उद्देश्य के लिए जेडीके में एक वर्ग है। इसे नामित किया गया है ( Sorted* से अन्य Sorted* इंटरफेस के साथ) " java.util.PriorityQueue " यह या तो Comparable<?> या एक Comparator का उपयोग करके सॉर्ट कर सकता है

Collections.sort(...) का उपयोग करके सॉर्ट किया गया एक List साथ अंतर यह है कि यह हर समय ओ (लॉग (एन)) प्रविष्टि प्रदर्शन के साथ, एक हेप डेटा संरचना का उपयोग करके एक आंशिक आर्डर बनाए रखेगा, जबकि एक सॉर्टिंग ArrayList ओ (एन) (यानी, द्विआधारी खोज और चाल का उपयोग करके) हो जाएगा।

हालांकि, एक List विपरीत, PriorityQueue अनुक्रमित एक्सेस ( get(5) ) का समर्थन नहीं करता है, एक ढेर में वस्तुओं का उपयोग करने का एकमात्र तरीका उन्हें एक बार में ले जाना है (इस प्रकार नाम की PriorityQueue )।

TreeMap और TreeSet आपको क्रमबद्ध क्रम में सामग्री पर एक पुनरावृत्ति देगा। या आप एक सरणी सूची का उपयोग कर सकते हैं और इसे व्यवस्थित करने के लिए कलेक्शन। ये सभी कक्षाएं java.util में हैं

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

Google Guava के TreeMultiset का उपयोग करें अमरूद एक शानदार संग्रह एपीआई है।

अमरीका: https://github.com/google/guava

ट्रीएमल्टीसिट: https://google.github.io/guava/releases/snapshot/api/docs/com/google/common/collect/TreeMultiset.html

सूची का कार्यान्वयन प्रदान करने में एक समस्या जो क्रमबद्ध आदेश को बनाए रखती है, 'ऐड' विधि के जवाडॉक्स में किए गए वादे हैं।

कुछ विकल्प हैं अगर आप डुप्लिकेट नहीं चाहते हैं तो आप ट्रीसेट का सुझाव देते हैं और जो वस्तु आप डालने जा रही हैं वह तुलनीय है।

आप ऐसा करने के लिए कलेक्शंस क्लास के स्थिर तरीकों का भी उपयोग कर सकते हैं।

अधिक जानकारी के लिए संग्रह # सॉर्ट (java.util.List) और ट्रीसेट देखें।

आप SortedSet लागूकरण चाहते हैं, अर्थात् TreeSet

यदि आप बस एक सूची को सॉर्ट करना चाहते हैं, तो किसी भी प्रकार की सूची का उपयोग करें और Collections.sort () का उपयोग करें। यदि आप यह सुनिश्चित करना चाहते हैं कि सूची में तत्व अद्वितीय और हमेशा सॉर्ट किए गए हैं, तो सॉर्टेडसेट का उपयोग करें।

मैंने जो कुछ किया है, वह सूची को कार्यान्वित कर रहा है, जिसमें सभी तरीकों के साथ एक आंतरिक उदाहरण दिया गया है।

  public class ContactList implements List<Contact>, Serializable { private static final long serialVersionUID = -1862666454644475565L; private final List<Contact> list; public ContactList() { super(); this.list = new ArrayList<Contact>(); } public ContactList(List<Contact> list) { super(); //copy and order list List<Contact>aux= new ArrayList(list); Collections.sort(aux); this.list = aux; } public void clear() { list.clear(); } public boolean contains(Object object) { return list.contains(object); } 

इसके बाद, मैंने एक नई विधि "पुट ऑर्डर" को लागू किया है जो सही स्थिति में सम्मिलित है अगर तत्व मौजूद नहीं है या बस के स्थान पर मौजूद है।

 public void putOrdered(Contact contact) { int index=Collections.binarySearch(this.list,contact); if(index<0){ index= -(index+1); list.add(index, contact); }else{ list.set(index, contact); } } 

यदि आप दोहराए जाने वाले तत्वों की अनुमति देना चाहते हैं तो इसके बजाय (या दोनों) addOrdered लागू करें

 public void addOrdered(Contact contact) { int index=Collections.binarySearch(this.list,contact); if(index<0){ index= -(index+1); } list.add(index, contact); } 

यदि आप आवेषण से बचने के लिए चाहते हैं तो आप "जोड़" और "सेट" विधियों पर भी फेंक सकते हैं और असमर्थित अपवाद अपवाद भी कर सकते हैं।

 public boolean add(Contact object) { throw new UnsupportedOperationException("Use putOrdered instead"); } 

… और आपको लिस्टइटरेटर विधियों से सावधान रहना होगा क्योंकि वे आपकी आंतरिक सूची को संशोधित कर सकते हैं। इस मामले में आप आंतरिक सूची की प्रतिलिपि वापस कर सकते हैं या फिर एक अपवाद फेंक सकते हैं।

 public ListIterator<Contact> listIterator() { return (new ArrayList<Contact>(list)).listIterator(); } 

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

लैम्ब्डा जे का उपयोग करना

यदि आप जावा 8 के पूर्व संस्करणों का उपयोग कर रहे हैं, तो आप इन कार्यों को लैम्ब्डाजे के साथ हल करने का प्रयास कर सकते हैं। आप इसे यहां पा सकते हैं: http://code.google.com/p/lambdaj/

यहां आपके पास एक उदाहरण है:

इन्टरेक्टिव सॉर्ट करें

 List<Person> sortedByAgePersons = new ArrayList<Person>(persons); Collections.sort(sortedByAgePersons, new Comparator<Person>() { public int compare(Person p1, Person p2) { return Integer.valueOf(p1.getAge()).compareTo(p2.getAge()); } }); 

LambdaJ के साथ क्रमबद्ध करें

 List<Person> sortedByAgePersons = sort(persons, on(Person.class).getAge()); 

बेशक, प्रदर्शन में इस प्रकार की सुंदरता प्रभाव (2 बार का औसत) होने पर क्या आप एक अधिक पठनीय कोड प्राप्त कर सकते हैं?

लैम्बडा अभिव्यक्ति के उपयोग से जावा 8 के साथ क्रमबद्ध करें

 Collections.sort(persons, (p1, p2) -> p1.getAge().compareTo(p2.getAge())); //or persons.sort((p1, p2) -> p1.getAge().compareTo(p2.getAge())); 

एक सॉर्ट की गई सूची को लागू करने का सबसे कारगर तरीका, जैसा कि आप चाहते हैं, यहां इंडेकेबल स्कीप्लिस्ट को लागू करना होगा: विकीपीडिया: इंडेक्सेबल स्कीप्लिस्ट इसमें ओ (लॉग (एन)) में सम्मिलित / निकाले जाने की अनुमति होगी और एक ही समय में अनुक्रमित पहुंच की अनुमति होगी। और यह डुप्लिकेट को भी अनुमति देगा

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

प्राथमिकता प्रश्न के साथ समस्या यह है कि इसका एक सरल सरणी द्वारा समर्थित है, और तत्व जो क्रम में तत्वों को प्राप्त करता है "कतार [2 * n + 1] और कतार [2 * (n + 1)]" चीज़ द्वारा किया जाता है यह बहुत अच्छा काम करता है अगर आप सिर से खींचते हैं, लेकिन इसे बेकार बना देता है यदि आप कॉल करने की कोशिश कर रहे हैं।

मैं com.google.common.collect.TreeMultimap का उपयोग करके इस समस्या के चारों ओर जाता हूं, लेकिन मैं एक ऑर्डरिंग में लिपेट किए गए मानों के लिए कस्टम कमांपरेटर की आपूर्ति करता हूं, जो कि 0 से कभी भी रिटर्न नहीं देता

पूर्व। डबल के लिए:

 private static final Ordering<Double> NoEqualOrder = Ordering.from(new Comparator<Double>() { @Override public int compare(Double d1, Double d2) { if (d1 < d2) { return -1; } else { return 1; } } }); 

इस तरह मुझे मूल्य मिलते हैं जब मैं कॉल करता हूं। टूअरे (), और इसके पास डुप्लिकेट हैं

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

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

आप ऐरेलिस्ट और ट्रेमेप का उपयोग कर सकते हैं, जैसा आपने कहा था कि आप दोहराए गए मान भी चाहते हैं, फिर आप ट्रीसैट का प्रयोग नहीं कर सकते हैं, हालांकि इसे सॉर्ट किया गया है, लेकिन आपको तुलनित्र को परिभाषित करना होगा

निम्नानुसार सूची को सॉर्ट करने के लिए सॉर्ट () विधि का उपयोग करें:

 List list = new ArrayList(); //add elements to the list Comparator comparator = new SomeComparator(); Collections.sort(list, comparator); 

संदर्भ के लिए लिंक देखें: http://tutorials.jenkov.com/java-collections/sorting.html

TreeSet उपयोग करें जो कि क्रमबद्ध क्रम में तत्व देता है। या Comparator() साथ बाहरी सॉर्टिंग के लिए Collection.sort() उपयोग करें।

 import java.util.TreeSet; public class Ass3 { TreeSet<String>str=new TreeSet<String>(); str.add("dog"); str.add("doonkey"); str.add("rat"); str.add("rabbit"); str.add("elephant"); System.out.println(str); }