Piccolo aiuto su oridinamento array, Heapsort,su oggetti

« Older Newer »

-AsCiA-

Posted on 10/9/2011, 17:24

oooh XD
instanceof non so ancora manco che cosa e' XD
cmq con un Object in se no,pero' dato che la funzione setCompareOption() e' static posso fare una roba tipo

CODICE

//Fai conto che gli oggetti person siano stati istanziati correttamente

Person oArray[] = {p1,p2,p3,p4}

Person.setCompareOption(Person.ODER_FOR_AGE);

Heap oHeap = new Heap;

oHeap.setData(oArray)

Person oSortedList[];

oSortedList = oHeap.sort();

non ho provato,ma in teoria dovrebbe andare...

Doch88

Posted on 10/9/2011, 17:31

CITAZIONE (-AsCiA- @ 10/9/2011, 18:24)

oooh XD
instanceof non so ancora manco che cosa e' XD
cmq con un Object in se no,pero' dato che la funzione setCompareOption() e' static posso fare una roba tipo

CODICE

non ho provato,ma in teoria dovrebbe andare...

Beh, con i Generics è uguale solo che al posto di fare

CODICE

Heap oHeap = new Heap();

devi fare:

CODICE

Heap<Person> oHeap = new Heap<Person>();

che quindi oHeap.sort(); ti ritornerà un array di Person e non di oggetti.

Comunque instanceof è solo un costrutto che serve per vedere se un oggetto di una classe è anche instanza di un altra classe (spesso sottoclasse o interfaccia).

Esempio:

Number è la superclasse di Integer.

Quindi:

CODICE

public boolean isInteger(Number a)
{
if(a instanceof Integer)
return true;
else return false;
}

-AsCiA-

Posted on 10/9/2011, 17:39

EDIT.
ho implementato costanti e metodi alla classe Person,ho modificato la classe di test passando questo dopo la crazione dell'array:

CODICE

Person.setCompareAttribute(Person.I_ORDER_FOR_AGE);

La classe Heap l'ho lasciata invariata..

Funzionaaa

ecco il risultato

CODICE

ARRAY DISORDINATO:
Name: d
Age: 20
Gender: M
Name: c
Age: 40
Gender: M
Name: b
Age: 30
Gender: M
Name: a
Age: 10
Gender: M

ARRAY ORDINATO:
Name: a
Age: 10
Gender: M
Name: d
Age: 20
Gender: M
Name: b
Age: 30
Gender: M
Name: c
Age: 40
Gender: M

Passando invece

CODICE

Person.setCompareAttribute(Person.I_ORDER_FOR_NAME);

il risultato e':

CODICE

ARRAY DISORDINATO:
Name: d
Age: 20
Gender: M
Name: c
Age: 40
Gender: M
Name: b
Age: 30
Gender: M
Name: a
Age: 10
Gender: M

ARRAY ORDINATO:
Name: a
Age: 10
Gender: M
Name: b
Age: 30
Gender: M
Name: c
Age: 40
Gender: M
Name: d
Age: 20
Gender: M

edit
abbiamo scritto assieme XD
ora leggo la tua risposta e vedo di capire

EDIT 2.
se passo un array ordinato me lo disordina ._.
o.o

CODICE

ARRAY DISORDINATO:
Name: d
Age: 10
Gender: M
Name: c
Age: 20
Gender: M
Name: b
Age: 30
Gender: M
Name: a
Age: 40
Gender: M

ARRAY ORDINATO:
Name: d
Age: 10
Gender: M
Name: c
Age: 20
Gender: M
Name: a
Age: 40
Gender: M
Name: b
Age: 30
Gender: M

Doch88

Posted on 10/9/2011, 17:48

Quello penso sia un problema dell'algoritmo :S

-AsCiA-

Posted on 10/9/2011, 18:00

eh gia ._.
ma non capisco se l'errore e' nell'implementazione di compareTo() o nella classe heap...
compareTo alla fine e' molto semplice

SPOILER (clicca per visualizzare)

CODICE

public int compareTo(Person oPerson2Arg)
{
//Intero di ritorno
int iCompareResult=0;

//Confronto per eta'
if(iCompareAttribute == I_ORDER_FOR_AGE)
{
int p1Age = this.getAge();
int p2Age = oPerson2Arg.getAge();

if(p1Age < p2Age)
{
iCompareResult = -1;
}

if(p1Age == p2Age)
{
iCompareResult = 0;
}

if(p1Age > p2Age)
{
iCompareResult= 1;
}
}

//Confronto per ordine lessicogfrafico del nome
if(iCompareAttribute == I_ORDER_FOR_NAME)
{
String p1Name = this.getName();
String p2Name = oPerson2Arg.getName();

//Per il confronto si utilizza il metodo compareTo della classe String
int iCompareValue= p1Name.compareToIgnoreCase(p2Name);

if(iCompareValue == 0)
{
iCompareResult = 0;
}

if(iCompareValue >=1)
{
iCompareResult = 1;
}

if(iCompareValue <=-1)
{
iCompareResult = -1;
}
}

return iCompareResult;
}

e la classe heap l'hai vista,non mi sembra che ci siano errori,alla fine la classe in se e' ok,la comparazione la fa fare a compareTo dell'Object da oridinare...

EDIT...
Ok,l'errore e' nella classe Heap,l'ho sostituita al volo con quella delle soluzioni e non disordina gli array ordinati,ovviamente...
ora cerco l'errore

anzi...ora stacco 10 minuti da java XD
tanto ormai so' in che classe e' l'errore,devo solo cercarlo,poi lo faccio con calma

-AsCiA-

Posted on 11/9/2011, 00:09

perfetto...
trovato l'errore,nel processo di costruzione alla chiamata di rebuild passavo come nodo il valore 0 invece che il valore i del ciclo for,quindi lavoravo sempre sul nodo radice,in pratica facevo quello che va fatto nella chiamata di rebuild all'interno del metodo di estrazione..
Sinceramente non so perche' l'unico errore che mi dava era sull'erray ordinato e riusciva comunque ad ordinarmi un array disordinato,o quantomeno riusciva con i vari array di test che passavo...
Doch,grazie mille per tutte le spiegazioni...
Un ultima cosa,con l'altro modo che mi stavi accennando,cioe' rendendo direttamente la classe Heap generica ho guadagni a livello di prestazioni,sai perche' te lo chiedo?
ho notato che adesso,si ordina tutti gli oggetti che implementano l'interfaccia comparable,ma non mi ordina piu' gli interi XD...
Con l'altra metodologia risolverei?
Altrimenti pensavo di creare un interfaccia Heap e poi creare HeapObject implements Heap ed HeapDouble implments Heap,in modo che abbiano la stessa struttura ma uno mi ordina gli oggetti mentre l'altro mo ordina double,e naturalmente interi castando il risultato in (int)...

Doch88

Posted on 11/9/2011, 13:07

Non dovrebbe fare così :S
Cioè ti dovrebbe vedere tutti, ma ti devi ricordare di metterli sempre tramite il Wrapper (Integer) e non il tipo (int).
Comunque si, penso che con i Generics sarebbe più facile risolvere =)

-AsCiA-

Posted on 12/9/2011, 19:19

hai ragione...
sbagliavo io,gli passavo un array di int come tipi di dato..
ora gli passo oggetti Integer e funziona bene...
grazie doch...
Diciamo che questo capitolo l'ho finito grazie a te XD

Edited by -AsCiA- - 12/9/2011, 23:43

Doch88

Posted on 13/9/2011, 17:16

Prego, per qualunque cosa chiedi =)

23 replies since 10/9/2011, 00:43 222 views