Pages: [1]   Go Down
Print
Author Topic: Problema Tipi Generici  (Read 1171 times)
0 Members e 1 Utente non registrato stanno visualizzando questa discussione.
atrix0ne
Forumista
***
Offline Offline

Posts: 607


homo faber fortunae suae


« on: 04-09-2010, 09:51:12 »

Salve ragazzi...ho un piccolo problema!
Se io ho una classe e utilizzo un metodo con tipi generici per esempio:
Code:
public class bubblesort
{
public static E [] bubblesort(E [] array)
{
....

}
public static void main (String [] args )
{
Integer [] array={10,1,20,30,2,8,7,11}; //
bubblesort(array); //ciò non lo posso fare!come dovrei scrivere per farlo funzionare?? :pray

}
}
Logged

Lynx90
Matricola
*
Offline Offline

Posts: 33



« Reply #1 on: 04-09-2010, 10:04:24 »

Dal codice che hai mostrato intuisco che tu voglia ordinare l'array,non sono completamente sicuro, ma credo che potresti scrivere una cosa del genere
Code:
public class bubblesort<E extends Comparable>{

public static<E extends Comparable> void bubblesort(E[] array){
codice x ordinare...
}
public static void main (String [] args )
{
Integer [] array={10,1,20,30,2,8,7,11}; //
bubblesort(array);

}
}
A questo punto l'array dovrebbe essere ordinato. Se non funziona prova ad implementare il main su una classe diversa, fammi sapere  ciao
Logged
atrix0ne
Forumista
***
Offline Offline

Posts: 607


homo faber fortunae suae


« Reply #2 on: 04-09-2010, 10:20:06 »

non funziona 
cmq ho provato cosi':
Code:
public class selectionsortg<E extends Comparable>
{
public  static <E extends Comparable> selectionsortg ( E [] array)
{
int i,j,least=0;
E temp=null;
for( i=0;i<array.length-1;i++)
{
for( j=i+1,least=i;j<array.length;j++)
if(array[j].compareTo(array[least])<0 )
least=j;
if(least!=i )
{
temp=array[least];
array[least]=array[i];
array[i]=temp;
}
}
}
public static void main(String [] args)
{
Integer [] array={10,13,4,9,8,1,6};
selectionsortg(array);
for(int i=0;i<array.length;i++)
System.out.println(array[i]);
}
}
ma nulla..mi dice:
selectionsortg.java:3: modifier static not allowed here
   public  static <E extends Comparable> selectionsortg ( E [] array)
                                         ^
selectionsortg.java:23: cannot find symbol
symbol  : method selectionsortg(java.lang.Integer[])
location: class selectionsortg<E>
   selectionsortg(array);
Logged

Lynx90
Matricola
*
Offline Offline

Posts: 33



« Reply #3 on: 04-09-2010, 10:52:02 »

credo di aver capito il tuo errore, non richiami il metodo correttamente, devi scrivere selectionsortg.selectionsortg(array). I metodi statici si richiamano scrivendo Nomeclasse.nomemetodo(parametri). Se hai ancora problemi ti posto l'esercizio sugli ordinamenti che c'è nel sistema di esercitazione,ho fatto questo usando dei metodi statici
Logged
atrix0ne
Forumista
***
Offline Offline

Posts: 607


homo faber fortunae suae


« Reply #4 on: 04-09-2010, 11:42:38 »

mi dà sempre lo stesso errore:
selectionsortg.java:23: cannot find symbol
symbol  : method selectionsortg(java.lang.Integer[])
location: class selectionsortg<E>
   selectionsortg(array);
Logged

Lynx90
Matricola
*
Offline Offline

Posts: 33



« Reply #5 on: 04-09-2010, 15:04:34 »

Boh a questo punto non so aiutarti, posto l'esercizio di cui parlavo prima, ci sono tutti gli ordinamenti che abbiamo fatto, magari può esserti di aiuto
Code:
import java.util.*;
class ordinamenti<E extends Comparable>{

public static<E extends Comparable> void swap(E[] array,int i,int j){ //SCAMBIA DUE ELEMENTI DI UN ARRAY
E swap=array[j];
array[j]=array[i];
array[i]=swap;
}

public static<E extends Comparable> void bubbleSort(E[] array){ //ESEGUE IL BUBBLESORT
for(int i=0;i<array.length;i++){
for(int j=0;j<array.length-1;j++){
if(array[j].compareTo(array[j+1])>0)
swap(array,j,j+1);
}
}
}

public static<E extends Comparable> void selectionSort(E[] array){  //ESEGUE IL SELECTION SORT
for(int i=0;i<array.length;i++){
int min=i;
for(int j=i+1;j<array.length;j++){
if(array[j].compareTo(array[min])<0)
min=j;
}
swap(array,i,min);
}
}

public static<E extends Comparable> void insertionSort(E[] array){ //ESEGUE L'INSERTIONSORT
for(int i=1;i<array.length;i++){
int position=i-1;
E key=array[i];
while(position>=0 && array[position].compareTo(key)>0){
array[position+1]=array[position];
position--;
}
array[position+1]=key;
}
}

public static<E extends Comparable> void quickSort(E[] array){ //BLOCCO DI CODICE PER IL QUICKSORT
quickSort(array,0,array.length-1);
}

public static<E extends Comparable> void quickSort(E[] array,int i,int j){
if(i>=j)
return;
int r=partition(array,i,j);
quickSort(array,i,r);
quickSort(array,r+1,j);
}

public static<E extends Comparable> int partition(E[] array,int i,int j){

int a=i-1;
int b=j+1;
E pivot=array[j];

while(a<b){
do{
a++;
}while(pivot.compareTo(array[a])>0);

do{
b--;
}while(pivot.compareTo(array[b])<0);

if(a<b){
swap(array,a,b);
}

}
if(a==b)
return b-1;
return b;
} //FINE BLOCCO QUICKSORT

public static<E extends Comparable> void mergeSort(E[] array){ //INIZIO BLOCCO MERGESORT
mergeSort(array,0,array.length-1);
}

public static<E extends Comparable> void mergeSort(E[] array,int i,int j){
if(i>=j) return;
int r=(i+j)/2;
mergeSort(array,i,r);
mergeSort(array,r+1,j);
merge(array,i,r,j);
}

public static<E extends Comparable> void merge(E[] array,int i,int r,int j){
int a=i; int b=r+1; int k=0;

E[] C=(E[])new Comparable[j-i+1];
while(a<=r && b<=j){
if(array[a].compareTo(array[b])<0)
C[k++]=array[a++];
else
C[k++]=array[b++];
}
if(a>r)
{
while(b<=j)
{
C[k++]=array[b++];
}
}
else{
while(a<=r)
{
C[k++]=array[a++];
}
}
for(int z=0;z<C.length;z++)
array[i+z]=C[z];
} //FINE BLOCCO MERGESORT
}

class OrdinaMain{

public static void main(String args[]){

Integer[] ar=new Integer[100];
for(int i=0;i<ar.length;i++)
ar[i]=(int)(Math.random()*1000)+1;// CARICO VALORI RANDOM DA 0 A 999
ordinamenti.bubbleSort(ar); //QUI RICHIAMO IL METODO STATICO CONTENUTO NELLA CLASSE ORDINAMENTI
System.out.println(Arrays.toString(ar));
System.out.println(end-start);
}
}

Aggiungere il tipo generico al modificatore static è comunque necessario, adesso non ricordo con precisione perchè, ma ne avevamo parlato con il professore nella lezione straordinaria che c'è stata per correggere alcuni compiti d'esame
« Last Edit: 04-09-2010, 15:11:56 by Lynx90 » Logged
atrix0ne
Forumista
***
Offline Offline

Posts: 607


homo faber fortunae suae


« Reply #6 on: 04-09-2010, 18:52:14 »

grazie gentilissimo  per caso avete fatto il compito B dell'ultimo esame??
Logged

Lynx90
Matricola
*
Offline Offline

Posts: 33



« Reply #7 on: 05-09-2010, 13:38:33 »

Quale compito? dici quello dove si deve implementare la classe OrderedSet? Di questo esercizio ne avevamo parlato con il professore proprio nella lezione straordinaria che abbiamo fatto, mi ricordo di averlo svolto ma non riesco a trovarlo nel mio incasinatissimo pc  . Cmq ho intenzione di farlo di nuovo questo pomeriggio e se ci riesco posto la mia soluzione. Giusto per restare in topic: il mio esercizio ti è stato di aiuto? sei riuscito a risolvere il problema?
Logged
atrix0ne
Forumista
***
Offline Offline

Posts: 607


homo faber fortunae suae


« Reply #8 on: 05-09-2010, 15:36:16 »

si sono riuscito a risolvere il problema!!grazie cmq si mi riferisco all'esercizio Orderedset!se riesci a risolverlo postalo!!grazie ancora ok
Logged

Lynx90
Matricola
*
Offline Offline

Posts: 33



« Reply #9 on: 05-09-2010, 15:43:14 »

Di niente figurati,d'altra parte noi studenti dobbiamo aiutarci in un modo o nell'altro  [Emoticon] Asd. Ho appena finito... devo dire che ho avuto più difficoltà rispetto alla prima volta, che dire, andiamo bene...  
Cmq ecco la mia soluzione
Code:
import java.util.*;
import java.io.*;
//CLASSE NODO
class DNode<E>{
private E element;
private DNode<E> next;
private DNode<E> prev;

public DNode(E element, DNode<E> prev,DNode<E> next){
this.element=element;
this.prev=prev;
this.next=next;
}

public E element(){return element;}
public DNode<E> next(){return next;}
public DNode<E> prev(){return prev;}
public void setElement(E element){this.element=element;}
public void setPrev(DNode<E> prev){this.prev=prev;}
public void setNext(DNode<E> next){this.next=next;}
}

//CLASSE LISTA
class LinkedList<E>{
private DNode<E> header,trailer;
private int size;
public LinkedList(){
header=new DNode<E>(null,null,null);
trailer=new DNode<E>(null,header,null);
header.setNext(trailer);
size=0;
}

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

public DNode<E> first(){
if(isEmpty())
return null;
return header.next();
}

public DNode<E> last(){
if(isEmpty())
return null;
return trailer.prev();
}

public void addFirst(E element){
if(element==null)
return;
DNode<E> newNode=new DNode<E>(element,header,header.next());
header.next().setPrev(newNode);
header.setNext(newNode);
size++;
}
public void addLast(E element){
if(element==null)
return;
DNode<E> newNode=new DNode<E>(element,trailer.prev(),trailer);
trailer.prev().setNext(newNode);
trailer.setPrev(newNode);
size++;
}
public void addBefore(DNode<E> node, E element){
if(element==null || node==null)
return;
DNode<E> newNode=new DNode<E>(element,node.prev(),node);
node.prev().setNext(newNode);
node.setPrev(newNode);
size++;
}

public void remove(DNode<E> node){
DNode<E> prev=node.prev();
DNode<E> next=node.next();
prev.setNext(next);
next.setPrev(prev);
node.setNext(null);
node.setPrev(null);
size--;
}

public String toString(){
String str="";
DNode<E> tmp=first();
while(tmp!=trailer){
str+=tmp.element()+" ";
tmp=tmp.next();
}
return str;
}
}

//CLASSE SET
class Set<E extends Comparable> implements OrderedSet270710<E>{

protected LinkedList<E> lista;
private Set(E[] array){
lista=new LinkedList<E>();
for(E x:array){
lista.addLast(x);
}
}

public int size(){return lista.size();}
public void insert(E element){
DNode<E> tmp=lista.first();
while(tmp.next()!=null && tmp.element().compareTo(element)>0)
tmp=tmp.next();
lista.addBefore(tmp,element);
}

public E delete(int i){
if(lista.isEmpty() || i>lista.size())
return null;
DNode<E> tmp=lista.first();
while(i>1)
tmp=tmp.next();
E toReturn=tmp.element();
lista.remove(tmp);
return toReturn;
}

public E visit(int i){
if(lista.isEmpty() || i>lista.size())
return null;
DNode<E> tmp=lista.first();
while(i>1){
tmp=tmp.next();
i--;
}
E toReturn=tmp.element();
return toReturn;
}

public E deleteMin(){
if(lista.isEmpty())
return null;
E toReturn=lista.first().element();
lista.remove(lista.first());
return toReturn;
}

public boolean contains(E element){
DNode<E> tmp=lista.first();
while(tmp!=null && tmp.element().compareTo(element)!=0)
tmp=tmp.next();
if(tmp==null)
return false;
return true;
}

public Iterator<E> iterator(){
return null;
}

public E findMax(){
if(lista.isEmpty())
return null;
return lista.last().element();
}

public static<E extends Comparable> OrderedSet270710<E> QuickSortBuild(E[] a){
quickSort(a,0,a.length-1);
return new Set<E>(a);
}

public static<E extends Comparable> void quickSort(E[] array,int i,int j){
if(i>=j)
return;
int r=partition(array,i,j);
quickSort(array,i,r);
quickSort(array,r+1,j);
}

public static<E extends Comparable> int partition(E[] array,int i,int j){
int a=i-1;
int b=j+1;
E pivot=array[j];
while(a<b){
do{
a++;
}while(pivot.compareTo(array[a])>0);

do{
b--;
}while(pivot.compareTo(array[b])<0);

if(a<b){
E swap=array[a];
array[a]=array[b];
array[b]=swap;
}
}
if(a==b)
return b-1;
return b;
}

public static<E extends Comparable> OrderedSet270710<E> SelectionSortBuild(E[] a){
for(int i=0;i<a.length;i++){
int min=i;
for(int j=i+1;j<a.length;j++){
if(a[j].compareTo(a[min])<0)
min=j;
}
E swap=a[i];
a[i]=a[min];
a[min]=swap;
}
return new Set<E>(a);
}
}

//CLASSE MAIN
class SetMain{
public static void main(String args[]) throws IOException{
Scanner in=new Scanner(new File("input.txt"));
PrintWriter out=new PrintWriter("output.txt");
int i=0;
while(in.hasNextInt()){
in.next();
i++;
}
in=new Scanner(new File("input.txt"));
Integer array[]=new Integer[i];
i=0;
while(in.hasNextInt()){
array[i++]=in.nextInt();
}
Set<Integer> set=(Set<Integer>)Set.QuickSortBuild(array);
for(i=0;i<5;i++)
set.deleteMin();
out.print(set.visit(3)+" ");
out.print(set.visit(5)+" ");
out.print(set.visit(7));
in.close();
out.close();
}
}

Edit: non mi piace molto l'implementazione del main, ho avuto difficoltà a stabilire la grandezza dell'array da ordinare,infatti ho scansionato il file 2 volte, se qualcuno sa come risolvere questo problema in modo più efficiente posti la sua soluzione, Grazie in anticipo...
« Last Edit: 05-09-2010, 15:46:45 by Lynx90 » Logged
Pages: [1]   Go Up
Print
Jump to: