जवाबों:
यह बहुत देर से आता है, लेकिन JDK में एक वर्ग है जो केवल क्रमबद्ध सूची होने के उद्देश्य से है। यह नाम दिया गया है (अन्य Sorted*इंटरफेस के साथ कुछ हद तक बाहर ) " java.util.PriorityQueue"। यह Comparable<?>या तो s या a का उपयोग करके सॉर्ट कर सकता है Comparator।
एक Listसॉर्ट किए गए उपयोग के साथ अंतर Collections.sort(...)यह है कि यह ओ (लॉग (एन)) सम्मिलन प्रदर्शन के साथ, एक ढेर डेटा संरचना का उपयोग करके, हर समय एक आंशिक क्रम बनाए रखेगा, जबकि एक सॉर्ट में डालने से ArrayListओ (एन) होगा (यानी, बाइनरी खोज और चाल का उपयोग करते हुए)।
हालांकि, एक के विपरीत List, PriorityQueueअनुक्रमित पहुंच ( get(5)) का समर्थन नहीं करता है , एक ढेर में आइटम तक पहुंचने का एकमात्र तरीका उन्हें बाहर निकालना है, एक समय में (इस प्रकार नाम PriorityQueue)।
ट्री मैप और ट्रीसेट आपको क्रमबद्ध क्रम में सामग्री पर एक पुनरावृत्ति देगा। या आप एक ArrayList का उपयोग कर सकते हैं और इसे सॉर्ट करने के लिए Collections.sort () का उपयोग कर सकते हैं। वे सभी वर्ग java.util में हैं
यदि आप एक सॉर्ट की गई सूची को बनाए रखना चाहते हैं, जिसे आप बार-बार संशोधित करेंगे (अर्थात एक संरचना, जो छांटे जाने के अलावा, डुप्लिकेट को अनुमति देती है और जिनके तत्वों को सूचकांक द्वारा कुशलता से संदर्भित किया जा सकता है), तो एक ArrayList का उपयोग करें लेकिन जब आपको एक तत्व सम्मिलित करने की आवश्यकता होती है , हमेशा उस इंडेक्स को निर्धारित करने के लिए Collections.binarySearch () का उपयोग करें जिस पर आप किसी दिए गए तत्व को जोड़ते हैं। उत्तरार्द्ध विधि आपको बताती है कि आपकी सूची को क्रमबद्ध क्रम में रखने के लिए आपको किस सूचकांक को सम्मिलित करने की आवश्यकता है।
Google अमरूद के ट्रीमूल्टसेट वर्ग का उपयोग करें । अमरूद का शानदार कलेक्शन एपीआई है।
क्रमबद्ध क्रम बनाए रखने वाली सूची के कार्यान्वयन को प्रदान करने में एक समस्या add()विधि के JavaDocs में किया गया वादा है ।
Listजो अंत में हमेशा जोड़ता है।
आप SortedSet कार्यान्वयन, अर्थात् TreeSet चाहते हैं ।
कुछ विकल्प हैं। यदि आप डुप्लिकेट नहीं चाहते हैं और आप जिन वस्तुओं को सम्मिलित कर रहे हैं, वे ट्रीसेट का सुझाव देंगे।
आप ऐसा करने के लिए संग्रह वर्ग के स्थिर तरीकों का भी उपयोग कर सकते हैं।
अधिक जानकारी के लिए संग्रह # सॉर्ट (java.util.List) और ट्रीसेट देखें ।
मैंने जो भी किया है वह सभी विधियों के साथ आंतरिक उदाहरण वाली सूची को लागू करना है।
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);
}के बाद, मैंने एक नया तरीका "putOrdered" लागू किया है जो उचित स्थिति में सम्मिलित होता है यदि तत्व मौजूद नहीं है या बस मौजूद है।
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();
}Listअनुबंध का उल्लंघन करता है । शायद केवल लागू करना बेहतर होगा Collection। और अगर ContactListछांटा गया है, तो अधिक कुशल होने के लिए contains()उपयोग binarySearchकिया जा सकता है।
आप जैसे चाहते हैं एक क्रमबद्ध सूची को लागू करने का सबसे कुशल तरीका यहाँ पर एक अनुक्रमिक स्किलिस्ट को लागू करना होगा: इंडेक्सेबल स्किलिस्ट । यह ओ (लॉग (एन)) में आवेषण / हटाने की अनुमति देगा और एक ही समय में अनुक्रमित पहुंच की अनुमति देगा। और यह डुप्लिकेट को भी अनुमति देगा।
Skiplist एक बहुत ही दिलचस्प है और, मैं कहूंगा, डेटा संरचना को कम करके। दुर्भाग्य से जावा बेस लाइब्रेरी में कोई अनुक्रमित स्किलिस्ट कार्यान्वयन नहीं है, लेकिन आप एक ओपन सोर्स कार्यान्वयन का उपयोग कर सकते हैं या इसे स्वयं लागू कर सकते हैं। समसामयिक Skipist कार्यान्वयन जैसे समवर्ती SkipListSet और ConcurrentSkipListMap हैं
ट्रीसेट काम नहीं करेगा क्योंकि वे डुप्लिकेट को प्लस की अनुमति नहीं देते हैं और वे विशिष्ट स्थिति पर तत्व लाने की विधि प्रदान नहीं करते हैं। प्राथमिकता क्यू काम नहीं करेगा क्योंकि यह विशिष्ट स्थिति पर तत्वों को लाने की अनुमति नहीं देता है जो सूची के लिए एक बुनियादी आवश्यकता है। मुझे लगता है कि जब तक आप डुप्लिकेट नहीं करते, तब तक O (logn) इंसर्ट समय के साथ जावा में सॉर्ट की गई सूची को बनाए रखने के लिए आपको अपने खुद के एल्गोरिदम को लागू करने की आवश्यकता है। हो सकता है कि कोई समाधान ट्रीमैप का उपयोग कर रहा हो, जहां कुंजी आइटम के एक उपवर्ग के बराबर होती है, ताकि डुप्लिकेट की अनुमति हो।
आप इन कार्यों को लेम्बडाज के साथ हल करने की कोशिश कर सकते हैं यदि आप जावा 8 से पहले के संस्करणों का उपयोग कर रहे हैं। आप इसे यहाँ पा सकते हैं: http://code.google.com/p/lambdaj/
यहाँ आपके पास एक उदाहरण है:
क्रमबद्ध Iterative
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());
}
}); लैंबडैज के साथ क्रमबद्ध करें
List<Person> sortedByAgePersons = sort(persons, on(Person.class).getAge()); बेशक, प्रदर्शन में इस तरह का सौंदर्य प्रभाव पड़ता है (औसतन 2 बार), लेकिन क्या आप अधिक पठनीय कोड पा सकते हैं?
Collections.sort(persons, (p1, p2) -> p1.getAge().compareTo(p2.getAge()));
//or
persons.sort((p1, p2) -> p1.getAge().compareTo(p2.getAge()));-(p1.getAge().compareTo(p2.getAge()))
प्रायोरिटी क्यू के साथ समस्या यह है कि यह एक साधारण सरणी द्वारा समर्थित है, और तर्क जो तत्वों को प्राप्त करता है, वह "कतार [2 * n + 1] और कतार [2 * (n + 1)]" चीज़ से होता है। यह बहुत अच्छा काम करता है यदि आप सिर्फ सिर से खींचते हैं, लेकिन इसे बेकार कर देता है यदि आप किसी बिंदु पर इसे .toArray को कॉल करने का प्रयास कर रहे हैं।
मैं 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;
}
}
});इस तरह से जब मैं .toArray () कॉल करता हूं, तो मुझे मूल्य मिलते हैं, और डुप्लिकेट भी होते हैं।
आप जो चाहते हैं वह एक बाइनरी सर्च ट्री है। यह खोज, निष्कासन और सम्मिलन के लिए लघुगणक पहुंच की पेशकश करते हुए क्रमबद्ध क्रम को बनाए रखता है (जब तक कि आपके पास एक पतित वृक्ष नहीं है - तब यह रैखिक है)। इसे लागू करना काफी आसान है और आप इसे सूची इंटरफ़ेस को लागू करने के लिए भी बना सकते हैं, लेकिन तब सूचकांक-पहुंच जटिल हो जाती है।
दूसरा दृष्टिकोण एक ArrayList और फिर एक बुलबुला सॉर्ट कार्यान्वयन है। क्योंकि आप एक समय में एक तत्व सम्मिलित या निकाल रहे हैं, सम्मिलन और निष्कासन के लिए पहुंच समय रैखिक हैं। खोजें लॉगरिदमिक हैं और इंडेक्स एक्सेस कंटीन्यू (कई बार लिंक्डलिस्ट के लिए अलग-अलग हो सकते हैं)। एकमात्र कोड जो आपको चाहिए वह है 5, शायद 6 प्रकार के बबल सॉर्ट।
आप Arraylist और Treemap का उपयोग कर सकते हैं, जैसा कि आपने कहा था कि आप बार-बार मान चाहते हैं और फिर आप TreeSet का उपयोग नहीं कर सकते, हालांकि इसे भी क्रमबद्ध किया गया है, लेकिन आपको तुलनित्र को परिभाषित करना होगा।
सेट के लिए आप ट्रीसेट का उपयोग कर सकते हैं। ट्रीसेट आदेश एक प्राकृतिक आदेश या उस विशेष वस्तु के लिए तुलनीय के लिए पारित किसी भी छंटनी आदेश के आधार पर तत्व है। मानचित्र के लिए TreeMap का उपयोग करें। ट्रीपाइप कुंजी पर छँटाई प्रदान करता है। ट्रीपॉइंट की कुंजी के रूप में एक ऑब्जेक्ट जोड़ने के लिए उस वर्ग को तुलनीय इंटरफ़ेस को लागू करना चाहिए जो बदले में () विधि की तुलना करने के लिए लागू करता है जिसमें सॉर्टिंग ऑर्डर की परिभाषा होती है। http://techmastertutorial.in/java-collection-impl.html
नीचे दी गई सूची को क्रमबद्ध करने के लिए सॉर्ट () विधि का उपयोग करें:
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जो तत्वों को क्रमबद्ध क्रम में देता है। या Collection.sort()बाहरी छँटाई के लिए उपयोग करें Comparator()।
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);
}Java 8 तुलनित्र के साथ, यदि हम सूची को क्रमबद्ध करना चाहते हैं, तो यहां दुनिया के 10 सबसे अधिक आबादी वाले शहर हैं और हम इसे समय के अनुसार रिपोर्ट करना चाहते हैं। ओसाका, जापान। ... मेक्सिको सिटी मेक्सिको। ... बीजिंग, चीन। ... साओ पाउलो ब्राज़ील। ... मुंबई, भारत। ... शंघाई, चीन। ... दिल्ली, भारत। ... टोक्यो, जापान।
import java.util.Arrays;
import java.util.Comparator;
import java.util.List;
public class SortCityList {
/*
* Here are the 10 most populated cities in the world and we want to sort it by
* name, as reported by Time. Osaka, Japan. ... Mexico City, Mexico. ...
* Beijing, China. ... São Paulo, Brazil. ... Mumbai, India. ... Shanghai,
* China. ... Delhi, India. ... Tokyo, Japan.
*/
public static void main(String[] args) {
List<String> cities = Arrays.asList("Osaka", "Mexico City", "São Paulo", "Mumbai", "Shanghai", "Delhi",
"Tokyo");
System.out.println("Before Sorting List is:-");
System.out.println(cities);
System.out.println("--------------------------------");
System.out.println("After Use of List sort(String.CASE_INSENSITIVE_ORDER) & Sorting List is:-");
cities.sort(String.CASE_INSENSITIVE_ORDER);
System.out.println(cities);
System.out.println("--------------------------------");
System.out.println("After Use of List sort(Comparator.naturalOrder()) & Sorting List is:-");
cities.sort(Comparator.naturalOrder());
System.out.println(cities);
}
}उपयोगकर्ता परिभाषित मापदंड के अनुसार एक ArrayList छँटाई।
मॉडल वर्ग
class Student
{
int rollno;
String name, address;
public Student(int rollno, String name, String address)
{
this.rollno = rollno;
this.name = name;
this.address = address;
}
public String toString()
{
return this.rollno + " " + this.name + " " + this.address;
}
} छँटाई कक्षा
class Sortbyroll implements Comparator<Student>
{
public int compare(Student a, Student b)
{
return a.rollno - b.rollno;
}
} मुख्य वर्ग
class Main
{
public static void main (String[] args)
{
ArrayList<Student> ar = new ArrayList<Student>();
ar.add(new Student(111, "bbbb", "london"));
ar.add(new Student(131, "aaaa", "nyc"));
ar.add(new Student(121, "cccc", "jaipur"));
System.out.println("Unsorted");
for (int i=0; i<ar.size(); i++)
System.out.println(ar.get(i));
Collections.sort(ar, new Sortbyroll());
System.out.println("\nSorted by rollno");
for (int i=0; i<ar.size(); i++)
System.out.println(ar.get(i));
}
} उत्पादन
Unsorted
111 bbbb london
131 aaaa nyc
121 cccc jaipur
Sorted by rollno
111 bbbb london
121 cccc jaipur
131 aaaa nyc