Sortieren einer Liste alphabetisch mit compareTo() Methode

Question

Ich schreibe ein Telefonbuch-Programm in Java und ich muss die Leute in der Liste alphabetisch auflisten, und ich muss einen Sortieralgorithmus für eine Liste in Java schreiben und es sollte verwenden nur compareTo() -Methode. Kann mir also jemand helfen?

public void listAlpha() 
{ 
    Node tempNode = head; 

    for(int i = 0; i <= size; i++) 
     { 
      for(int j = 0; j <= i; j++) 
      { 
       int comparison = ((tempNode.getNext().getElement().getName()).compareTo(tempNode.getElement().getName())); 
       if(comparison < 0) 
       { 
        Person tempPerson = tempNode.getElement(); 

        tempNode.setElement(tempNode.getNext().getElement()); 
        tempNode.getNext().setElement(tempPerson); 
        tempNode = tempNode.getNext(); 
       } 
      } 


     } 

(By the way ist dies eine Hausaufgaben und ich bin meine eigene Datenstrukturen verwenden.)

Dies ist die Klasse ist, dass Verfahren i oben gehört schrieb:

import java.util.*; 

/** Singly linked list implementation .*/ 
public class SLinkedList<E> implements LinkedList<E>, Iterable<E> { 
    protected Node<E> head;  // head node of the list 
    protected Node<E> tail;  // tail node of the list 
    protected int size;  // number of nodes in the list 

    public Iterator<E> iterator() 
    { 
     return new LinkedListIterator(head); 
    } 

    /** Default constructor that creates an empty list */ 
    public SLinkedList() { 
    head = null; 
    tail = null; 
    size = 0; 
    } 

    public int size() { 
    return size; 
    } 

    public boolean isEmpty() { 
    return size == 0; 
    } 

    public void addFirst(E newElement) { 
    Node<E> newNode = new Node(newElement,null); 
    if(size == 0) //if list is empty 
     tail = newNode; 

    newNode.setNext(head); 
    head = newNode; 
    size++; 
    } 

    public void addLast(E newElement) { 
    Node<E> newNode = new Node(newElement,null); 

    if(size == 0) //if list is empty 
     head = newNode; 

    if (size != 0) //if list is not empty 
     tail.setNext(newNode); 

    tail = newNode; 
    size++; 
    } 

    public E removeFirst() { 
    Node<E> tempNode = null; 
    if (size != 0) { 
     if(size == 1) 
      tail = null; 

     tempNode = head; 
     head = head.getNext(); 
     tempNode.setNext(null); 
     size--; 
    } 

    //if list is empty then return null 
    return tempNode.getElement(); 

    } 

    public E removeLast() { 
    Node<E> tempNode = head; 

    if(size == 0) 
     return null; 

    if(size == 1) { 
     head = null; 
     tail = null; 
     size--; 
     return tempNode.getElement(); 
    } 

    //size is greater than 1 
    for(int i=1; i<=size-2; i++) { 
     tempNode = tempNode.getNext(); //go to element that before the tail 
    } 

    Node<E> tempNode2 = tail; 
    tail = tempNode; 
    tail.setNext(null); 
    size--; 
    return tempNode2.getElement(); 

    } 

    public void remove(E element){ 
    int index = 0; 
    boolean found = false; 
    Node<E> temp = head; 
    for(int i=1; i<=size; i++) {//find the node with element 
     index++; 
     if(temp.getElement().equals(element)){ 
      found = true; 
      break; 
     } 
     temp = temp.getNext(); 
    } 

    if(found){ 
     if(index == 1) 
      removeFirst(); 

     else if(index == size) 
      removeLast(); 

     else{ 
      //find the previous node 
      Node<E> prev = head; 
      for(int i=1; i<index-1; i++) { 
       prev = prev.getNext(); 
      } 

      prev.setNext(temp.getNext()); 
      temp.setNext(null); 
      size--; 
     } 
    } 
    } 

    public int searchList(E searchKey) { 
    if(size == 0) 
     return -1; 

    Node tempNode = head; 
    for(int i=1; i<=size; i++) { 
     if(tempNode.getElement().equals(searchKey)) 
      return i; //return index of the node 
     tempNode = tempNode.getNext(); 
    } 

    return -1; //not found 
    } 

    public void printList() { 
    Node tempNode = head; 
    for(int i=1; i<=size; i++) { 
     System.out.print(tempNode.getElement()); 
     if(i!=size) //if it is not last element 
      System.out.print(" - "); 
     tempNode = tempNode.getNext(); 
    } 
    System.out.println(); 

    } 

Person Klasse:

public class Person 
{ 
    private String name; 
    private String surname; 
    private String address; 
    private PhoneNumber phone1; 
    private PhoneNumber phone2; 
    private PhoneNumber phone3; 

    public Person() 
    { 
     name = null; 
     surname = null; 
     address = null; 
     phone1.setPhone(0); 
     phone1.setType(""); 
     phone2.setPhone(0); 
     phone2.setType(""); 
     phone3.setPhone(0); 
     phone3.setType(""); 
    } 

    public Person(String n, String s, String a,PhoneNumber p1, PhoneNumber p2, PhoneNumber p3) 
    { 
     name = n; 
     surname = s; 
     address = a; 
     phone1 = p1; 
     phone2 = p2; 
     phone3 = p3; 

    } 

    public String getName() 
    { 
     return name; 
    } 

    public void setName(String n) 
    { 
     name = n; 
    } 
    public String getSur() 
    { 
     return surname; 
    } 

    public void setSur(String s) 
    { 
     surname = s; 
    } 

    public void insertPhone(PhoneNumber phone) 
    { 
     if(phone2 == null) 
      phone2 = phone; 
     else if(phone3 == null) 
      phone3 = phone; 
    } 

    public PhoneNumber getPhone1() 
    { 
     return phone1; 
    } 

    public PhoneNumber getPhone2() 
    { 
     return phone2; 
    } 

    public PhoneNumber getPhone3() 
    { 
     return phone3; 
    } 

    public String getAdd() 
    { 
     return address; 
    } 

    public void setAdd(String a) 
    { 
     address = a; 
    } 

Answer 1

Wie alle anderen bereits erwähnt haben, ist compareTo Teil der Schnittstelle.

Wie Sie es implementieren, hängt davon ab, ob Sie zuerst nach Nachnamen oder Namen sortieren möchten und ob sie aufsteigend sortiert werden sollen.

Zum Beispiel, wenn Sie mit dem Nachnamen bestellen möchten, zuerst in aufsteigender Reihenfolge:

public class Person implements Comparable<Person> { 
    // the parts of Person you already have would go here 
    public int compareTo(Person person) { 
     if (person == null) { 
      return -1; 
     } 

     if (surname != null && person.getSur() == null) { 
      return -1; 
     } else if (surname == null && person.getSur() != null) { 
      return 1; 
     } else if (surname != null && person.getSur() != null) { 
      int compare = surname.compareToIgnoreCase(person.getSur()); 
      if (compare != 0) { 
       return compare; 
      } 
     } 
     // Note that we did nothing if both surnames were null or equal 

     if (name == null && person.getName() == null) { 
      return 0; 
     } else if (name != null && person.getName() == null) { 
      return -1; 
     } else if (name == null && person.getName() != null) { 
      return 1; 
     } else { 
      return name.compareToIgnoreCase(person.getName()); 
     } 
    } 
} 

(habe ich nicht getestet tatsächlich diesen Code)

Diese über die Umsetzung der compareToIgnoreCase String beruht.

Beachten Sie, dass dadurch auch alle Nullobjekte und Objekte mit Nullnamen und Nachnamen am Ende der Liste verschoben werden.

Nach alledem, wenn Sie Comparable implementieren, können Sie die Collections-API dazu bringen, die Arbeit für Sie mit sort zu erledigen.

Wenn Sie feststellen, dass Sie mehrere verschiedene Sortiermethoden für ein Objekt benötigen, können Sie stattdessen eine Reihe von Comparator-Objekten erstellen, um die Sortierung durchzuführen.

Answer 2

Comparable in Ihrer Person-Klasse implementieren.

Ihre Methode compareTo() würde dann wie etwas sein:

public int compareTo(Person other) { 
    return name.compareTo(other.getName()) 
} 

Dann Collections.sort(<your list of Person>);

Answer 3

Sie können Ihre Person Klasse Comparable, und definieren Sie die folgende Methode implementieren machen:

public class Person implements Comparable<Person> { 

     // Your previous code 

     public int compareTo(Person other) { 
      if (other == null) { 
      // throw exception for example 
      } 
      return this.name.toLowerCase().compareTo(other.name.toLowerCase()); 
     } 
    } 

Answer 4

Die Unterschrift der Personenklasse sollte wie folgt lauten:

public class Person implements Comparable<Person> 

Fügen Sie die compareTo-Methode zur Personenklasse hinzu und verwenden Sie Collections.sort (personList) als starf vorgeschlagen.