implementazione metodo di ordinamento con comparator

[InfoLuca]

Salve a tutti!

Come da titolo ho un problema con un metodo di ordinamento che riceve un oggetto comparator e ordina una lista concatenata da me creata, purtroppo sto impazzendon in quando non mi esce

se qualcuno può aiutarmi e farmi capire dove sbaglio gli sono davvero grato!
questo è il metodo da creare:
"Il metodo sort() riceve un oggetto Comparator<T> e ordina, ad esempio con algoritmo bubble sort, la lista.
Attenzione che quando uno scambio è richiesto tra i contenuti di due nodi, vanno scambiate sole le
informazioni. Non toccare i puntatori durante gli scambi."

ho caopito che bisogna iplementare l'interfaccia Comparator e il metodo compare, questo l'ho fatto, ma credo di averlo sbagliato, anche perchè non so cosa passargli poi veramente al momento dell'invocazione del metodo, ecco il codice che ho scritto (e che è sicuramente errato ):

public void sort( Comparator comp) {
	ListIterator<T> ite=listIterator();
	Nodo corrente= new Nodo();
	Nodo successivo= new Nodo();int l=size();
	Nodo temp=new Nodo();
	for(int i=0; i<l; i++){
		
    if (comp.compare(corrente, successivo)>0){
		temp.info=corrente.info;
        corrente.info=successivo.info;
        successivo.info=corrente.info;} corrente=corrente.next;successivo=successivo.next;
		    
	  }
	
		
}

  public class  nodoCompare implements Comparator<Nodo>{
   
	public nodoCompare(){}//ordinamento in base alla lunghezza delle stringhe che rappresentano gli argomenti dei nodi
	public int compare(Nodo a, Nodo b) {
		String s1=(String) a.info;String s2=(String) b.info;
		if (s1.length() > s2.length())return 1;
		if (s1.length() < s2.length())return -1;
		return 0;
	}     }

[InfoLuca]

Nessuno sa niente?

OK sono rovinato

[Andrea1979]

Sei rovinato se non impari a fare ricerche in internet. Ci sono, probabilmente, un paio di milioni di pagine con spiegazioni ed esempi di codice su Comparator e Generics.
Una su tutte, il PDF "ufficiale" della sun sui Generics: un inizio più che sostanzioso.

http://java.sun.com/j2se/1.5/pdf/generics-tutorial.pdf

cerca "Comparato" in quel documento. E sbizzarisciti su qualsiasi motore di ricerca con:

java comparator generics

[InfoLuca]

oh...grazie,avevo perso la speranza che qualcuno rispondesse!

Cmq certo, prima di postare , vedo sempre di trovare qualcosa su internet e in questo caso non è stato di meno, solo che non sono riuscito a trovare granchè, tutti spiegavano cos'era il comparator e come implementare l'interfaccia, fino a qui ci sono, quello che mi sfugge e come creare il metodo di ordinamento che riceve un comparator e ordina una LinkledList. ora do un occhiata al pdf sperando di trovare qualcosa ......ti ringrazio!

[InfoLuca]

ho letto il pdf però non ho trovato nulla di quello che cercavo, anche perchè non vado proprio d'accordo con l'inglese ....

Ho ridefinito la classe Comparator con il metodo compare e questo funziona, e mi crea l'oggetto comparator se la istanzio facendo new oggetto.

public class CompString implements Comparator {
   public int compare(Object a, Object b) {
    if (!(a instanceof String) || !(b instanceof String)) {}
    String a1 = (String)a;
    String b1 = (String)b;
    if (a1.length()>b1.length()) return 1;
    else if (a1.length()==b1.length())
    	return a1.compareTo(b1);//A parità di lunghezza ordiniamo alfabeticamente
    else return -1;
   }
 }

l'ho anche testato con Arrays.sort(a, new CompString) e funziona, il problema è dunque al metodo di ordinamento...

[andbin]

Originariamente inviato da InfoLuca
Ho ridefinito la classe Comparator con il metodo compare e questo funziona

Prima cosa: ti è stato suggerito/imposto esplicitamente di prendere in considerazione le lunghezze e solo a lunghezza uguale fare il confronto lessicografico?
Perché ovviamente è un qualcosa in più .... è un altro criterio di ordinamento. Una stringa più corta infatti potrebbe essere "maggiore" di un'altra più lunga.

Seconda cosa: nel compareTo()/compare() di Comparable/Comparator, se non si usano i generics (quindi i parametri sono Object) generalmente non si fanno test di tipo con instanceof. Basta il cast perché ci si aspetta che gli oggetti siano quelli secondo il cast. Se il cast fallisce a runtime, il metodo esce con ClassCastException e questo è appropriato e previsto secondo le specifiche di Comparable/Comparator.

Originariamente inviato da InfoLuca
il problema è dunque al metodo di ordinamento...

Il metodo sort che hai postato all'inizio comunque non è appropriato. Vuoi usare il bubble-sort? Bene basta che guardi qui:

http://it.wikipedia.org/wiki/Bubble_sort

e vedi chiaramente che per fare un bubble-sort servono 2 cicli annidati.

[InfoLuca]

non mi è stato chiesto di ordinare secondo un parametro preciso, il fatto di scegliere la lunghezza delle stringhe che compongono l'informazione del nodo è stata una mia scelta.

In quanto ai generici, il compare di Comparator l'ho implementato passandogli due oggetti, ed infatti questo funziona, il problema, quando vado ad eseguire il programma è al metodo sort.

Il metodo sort non deve essere per forza bubble-sort, ne basta qualsiasi purchè si riesca ad ordinare la lista.
Sto cercando di modificare più volte il sort ma senza risultato, esce sempre qualche errore che mi impedisce di eseguirlo correttamente, attualmente mi sto concentrando su questo:

   public void sort(Comparator<T> compString) {
		
		int cont=0;
		 if (this==null)
		    return ;
		 Nodo tmp=first.next; Nodo tmp1=null;
		 while (tmp!=null){
		    if (compString.compare((T) tmp.info ,first.info )>0){
		       tmp1.info=tmp.info;
		       tmp.info=first.info;
		       first.info=(T) tmp1.info;
		    }
		    first=first.next;
		    tmp=tmp.next;
		 }
		
		 }

forse non riesco a scorrerlo, magari l'iteratore potrebbe aiutarmis e lo invoco?

[andbin]

Originariamente inviato da InfoLuca
Il metodo sort non deve essere per forza bubble-sort

Ok ma dovresti comunque implementare uno degli algoritmi di ordinamento "noti": quick-sort, merge-sort, heap-sort, ecc....

Dubito, permettimi di dirlo, che tu riesca ad "inventare" un algoritmo di ordinamento che alla fin fine non "cade" a livello concettuale in uno di quelli già noti e riconosciuti .....