Java hoe een gekoppelde lijst te sorteren?

Ik moet een gelinkte lijst alfabetisch sorteren. Ik heb een gekoppelde lijst vol met passagiersnamen en ik wil dat de passagiersnaam alfabetisch wordt gesorteerd. Hoe zou men dit doen? Heeft iemand referenties of video’s?


Antwoord 1, autoriteit 100%

Je kunt Collections#sortom dingen alfabetisch te sorteren.


Antwoord 2, autoriteit 72%

Om Strings alfabetisch te sorteren, moet je een Collatorgebruiken, zoals:

LinkedList<String> list = new LinkedList<String>();
 list.add("abc");
 list.add("Bcd");
 list.add("aAb");
 Collections.sort(list, new Comparator<String>() {
     @Override
     public int compare(String o1, String o2) {
         return Collator.getInstance().compare(o1, o2);
     }
 });

Omdat als je gewoon Collections.sort(list)aanroept, je problemen krijgt met strings die hoofdletters bevatten.

Bijvoorbeeld in de code die ik heb geplakt, zal de lijst na het sorteren zijn: [aAb, abc, Bcd]maar als je gewoon Collections.sort(list);je krijgt: [Bcd, aAb, abc]

Opmerking: wanneer u een Collatorgebruikt, kunt u de landinstelling Collator.getInstance(Locale.ENGLISH)opgeven, dit is meestal erg handig.


Antwoord 3, autoriteit 28%

In java8 hoef je de methode Collections.sort niet langer te gebruiken, omdat LinkedList de methode sort overneemt van java.util.List, dus Fido’s antwoord aanpassen aan Java8:

   LinkedList<String>list = new LinkedList<String>();
    list.add("abc");
    list.add("Bcd");
    list.add("aAb");
    list.sort( new Comparator<String>(){
    @Override
        public int compare(String o1,String o2){
            return Collator.getInstance().compare(o1,o2);
        }
    });

Referenties:

http://docs.oracle.com/ javase/8/docs/api/java/util/LinkedList.html

http://docs.oracle.com/ javase/7/docs/api/java/util/List.html


Antwoord 4, autoriteit 14%

Elegante oplossing sinds JAVA 8:

LinkedList<String>list = new LinkedList<String>();
list.add("abc");
list.add("Bcd");
list.add("aAb");
list.sort(String::compareToIgnoreCase);

Een andere optie is het gebruik van lambda-expressies:

list.sort((o1, o2) -> o1.compareToIgnoreCase(o2));

Antwoord 5, autoriteit 11%

Hier is het voorbeeld om geïmplementeerde gekoppelde lijsten in Java te sorteren zonder gebruik te maken van standaard Java-bibliotheken.

package SelFrDemo;
class NodeeSort {
    Object value;
    NodeeSort next;
    NodeeSort(Object val) {
        value = val;
        next = null;
    }
    public Object getValue() {
        return value;
    }
    public void setValue(Object value) {
        this.value = value;
    }
    public NodeeSort getNext() {
        return next;
    }
    public void setNext(NodeeSort next) {
        this.next = next;
    }
}
public class SortLinkList {
    NodeeSort head;
    int size = 0;
    NodeeSort add(Object val) {
        // TODO Auto-generated method stub
        if (head == null) {
            NodeeSort nodee = new NodeeSort(val);
            head = nodee;
            size++;
            return head;
        }
        NodeeSort temp = head;
        while (temp.next != null) {
            temp = temp.next;
        }
        NodeeSort newNode = new NodeeSort(val);
        temp.setNext(newNode);
        newNode.setNext(null);
        size++;
        return head;
    }
    NodeeSort sort(NodeeSort nodeSort) {
        for (int i = size - 1; i >= 1; i--) {
            NodeeSort finalval = nodeSort;
            NodeeSort tempNode = nodeSort;
            for (int j = 0; j < i; j++) {
                int val1 = (int) nodeSort.value;
                NodeeSort nextnode = nodeSort.next;
                int val2 = (int) nextnode.value;
                if (val1 > val2) {
                    if (nodeSort.next.next != null) {
                        NodeeSort CurrentNext = nodeSort.next.next;
                        nextnode.next = nodeSort;
                        nextnode.next.next = CurrentNext;
                        if (j == 0) {
                            finalval = nextnode;
                        } else
                            nodeSort = nextnode;
                        for (int l = 1; l < j; l++) {
                            tempNode = tempNode.next;
                        }
                        if (j != 0) {
                            tempNode.next = nextnode;
                            nodeSort = tempNode;
                        }
                    } else if (nodeSort.next.next == null) {
                        nextnode.next = nodeSort;
                        nextnode.next.next = null;
                        for (int l = 1; l < j; l++) {
                            tempNode = tempNode.next;
                        }
                        tempNode.next = nextnode;
                        nextnode = tempNode;
                        nodeSort = tempNode;
                    }
                } else
                    nodeSort = tempNode;
                nodeSort = finalval;
                tempNode = nodeSort;
                for (int k = 0; k <= j && j < i - 1; k++) {
                    nodeSort = nodeSort.next;
                }
            }
        }
        return nodeSort;
    }
    public static void main(String[] args) {
        SortLinkList objsort = new SortLinkList();
        NodeeSort nl1 = objsort.add(9);
        NodeeSort nl2 = objsort.add(71);
        NodeeSort nl3 = objsort.add(6);
        NodeeSort nl4 = objsort.add(81);
        NodeeSort nl5 = objsort.add(2);
        NodeeSort NodeSort = nl5;
        NodeeSort finalsort = objsort.sort(NodeSort);
        while (finalsort != null) {
            System.out.println(finalsort.getValue());
            finalsort = finalsort.getNext();
        }
    }
}

Antwoord 6, Autoriteit 8%

Node mergeSort(Node head) {
    if(head == null || head.next == null) {
        return head;
    }
    Node middle = middleElement(head);
    Node nextofMiddle = middle.next;
    middle.next = null;
    Node left = mergeSort(head);
    Node right = mergeSort(nextofMiddle);
    Node sortdList = merge(left, right);
    return sortdList;
}
Node merge(Node left, Node right) {
    if(left == null) {
        return right;
    }
    if(right == null) {
        return left;
    }
    Node temp = null;
    if(left.data < right.data) {
        temp = left;
        temp.next = merge(left.next, right);
    } else {
        temp = right;
        temp.next = merge(left, right.next);
    }
    return temp;
}
Node middleElement(Node head) {
    Node slow = head;
    Node fast = head;
    while (fast != null && fast.next != null && fast.next.next != null) {
        fast = fast.next.next;
        slow = slow.next;
    }
    return slow;
}

Antwoord 7, Autoriteit 6%

ik zou het niet doen. Ik zou een arrayclist of een gesorteerde collectie gebruiken met een comparator. Het sorteren van een Linkedlist gaat over de meest inefficiënte procedure die ik kan bedenken.


Antwoord 8, Autoriteit 6%

U kunt het doen door Java 8 Lambda Expression:

LinkedList<String> list=new LinkedList<String>();
list.add("bgh");
list.add("asd");
list.add("new");
//lambda expression
list.sort((a,b)->a.compareTo(b));

Antwoord 9

Als u wilt weten hoe u een gekoppelde lijst kunt sorteren zonder standaard Java-bibliotheken te gebruiken, zou ik u voorstellen om naar verschillende algoritmen te kijken. VOORBEELDEN Hier tonen hoe u een Insertion Sorteer, een ander StackoverFlow-bericht toont een samenvoegen sorteren , en ehow geeft zelfs enkele voorbeelden over het maken van een aangepaste vergelijkingsfunctie in Hoes u uw soort verder wilt aanpassen.

Other episodes