Sortowanie listy alfabetycznie za pomocą metody compareTo()

Question

Piszę program książki telefonicznej w języku java i muszę listować ludzi na liście alfabetycznie i zrobić to, że muszę napisać algorytm sortowania listy w java i powinien on użyć tylko metoda compareTo(). Czy ktoś może mi w tym pomóc?

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(); 
       } 
      } 


     } 

(Nawiasem mówiąc jest to praca domowa i używam własnych struktur danych).

Jest to klasa, która metoda napisałem powyżej należy:

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(); 

    } 

class Person:

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

Jak wszyscy inni wspomnieli, compareTo jest częścią interfejsu Comparable.

Sposób wdrożenia zależy od tego, czy chcesz najpierw zamówić przez nazwisko, czy nazwę, a jeśli chcesz, posortować je w kolejności rosnącej.

Na przykład, jeśli chcesz zamówić przez nazwiskiem pierwszy w kolejności rosnącej:

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()); 
     } 
    } 
} 

(I faktycznie nie testować ten kod)

ta opiera się na realizacji String dnia compareToIgnoreCase.

Zauważ, że ten porusza również wszystkie obiekty i przedmioty zerowe null imion i nazwisk na końcu listy.

powiedziawszy, wszystko, jeśli wdrożenie porównywalne, można dokonać zbiorów API do pracy dla używasz sort.

Jeśli okaże się, że potrzebujesz kilku różnych metod sortowania dla obiektu, możesz utworzyć zestaw obiektów Comparator, aby zamiast tego sortować.

Answer 2

Wykonaj Comparable w swojej klasie Person.

metoda Twój compareTo() byłaby wtedy coś takiego:

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

następnie użyć Collections.sort(<your list of Person>);

Answer 3

Można dokonać klasa Person wdrożyć Comparable i zdefiniować w następujący sposób:

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

Podpis osoby klasy powinien wyglądać następująco:

public class Person implements Comparable<Person> 

Dodaj metodę compareTo do klasy Person i użyj Collections.sort (personList) zgodnie z sugestią starf.