A me non funziona....in quel modo mi dŕ sempre problemi, se provo a dichiarare statici anche swap e SelectionSort.....scusami..posto l'intero codice:
codice:
import java.util.*;
import java.io.*;
interface OrderedSet270710<E extends Comparable> /*extends Iterable<E>*/{
public int size ();
// ritorna il numero di elementi dell'insieme
public void insert (E elem);
// inseirsce un nuovo elemento nell'insieme
public E delete(int i);
// elimina e ritorna l'elemento di posizione i dell'insieme
public E deleteMin();
// elimina e ritorna l'elemento piů piccolo dell'insieme
public boolean contains(E elem);
// ritorna true se l'elemnto č contenuto nell'insieme
public Iterator<E> iterator();
// ritorna un iteratore di tutti gli stack dell'albero
public E findMax ();
// ritorna l'elemento piů grande dell'insieme
}
class Node<E>
{
private E element;
private Node<E> next;
public Node(E element)
{
this.element=element;
next=null;
}
public E getElement(){return element;}
public void setNext(Node<E> next){this.next=next;}
public Node<E> getNext(){return next;}
}
class LinkedList<E extends Comparable>
{
private Node<E> head;
// private Node<E> tail;
private int size;
public LinkedList()
{
head=/*tail*/null;
size=0;
}
public Node<E> getHead(){return head;}
//public Node<E> getTail(){return tail;}
public int getSize(){return size;}
public void setHead(Node<E> head){this.head=head;}
// public void setTail(Node<E> tail){this.tail=tail;}
public void addNode(Node<E> node)
{
if(size==0){
head=node;
//tail=node;
}
else{
Node<E> succ=getHead();
Node<E> prec=getHead();
boolean inserito=false;
while(!inserito && succ!=null)
{
if(succ.getElement().compareTo(node.getElement())>0)
{
if(getHead()==succ)
{
node.setNext(head);
head=node;
inserito=true;
}
else{
prec.setNext(node);
node.setNext(succ);
inserito=true;
}
}
else
prec=succ;
succ=succ.getNext();
}
if(inserito==false){
prec.setNext(node);
//tail=node;
}
}
size++;
}
public Node<E> remove(Node<E> node)
{
if(size==0) return null;
Node<E> current=getHead();
Node<E> prec=getHead();
while(current!=node)
{
prec=current;
current=current.getNext();
}
if(current==getHead()){
current.setNext(null);
head=current.getNext();
size--;
return current;
}
else{
prec.setNext(current.getNext());
current.setNext(null);
size--;
return current;
}
}
}
class Insieme<E extends Comparable> implements OrderedSet270710<E>
{
private LinkedList<E> lista;
private int size;
private Insieme()
{
lista=new LinkedList();
size=0;
}
public int size(){return size;}
public void insert(E elem)
{
Node<E> nuovo=new Node(elem);
lista.addNode(nuovo);
}
public E delete(int i)
{
if(size==0) return null;
int j=0;
Node<E> tmp=lista.getHead();
while(j!=i)
{
tmp=tmp.getNext();
j++;
}
Node<E> remove=lista.remove(tmp);
size--;
return remove.getElement();
}
public E deleteMin()
{
Node<E> tmp=lista.getHead();
lista.remove(tmp);
size--;
return (E)tmp;
}
public boolean contains(E elem)
{
boolean isPresent=false;
if(size==0) return isPresent;
Node<E> tmp=lista.getHead();
while(!isPresent && tmp!=null)
{
if(tmp.getElement().equals(elem))
isPresent=true;
tmp=tmp.getNext();
}
return isPresent;
}
public Iterator<E> iterator(){return null;}
public E findMax()
{
if(size==0) return null;
Node<E> tmp=lista.getHead();
while(tmp.getNext()!=null)
tmp=tmp.getNext();
return tmp.getElement();
}
//public static <E extends Comparable> OrderedSet270710<E> QuickSortBuild (E[] a);
// ritorna un'istanza della classe contenente gli elementi di a
// utilizza il QuickSort per l'ordinamento
public static <E extends Comparable>OrderedSet270710<E> SelectionSortBuild(E[] a)
{
SelectionSort(a);
Insieme<E> set=new Insieme();
for(int i=0; i<a.length; i++)
set.insert(a[i]);
return set;
}
public static void swap(E[] a, int i, int j)
{
E tmp=a[i];
a[i]=a[j];
a[j]=tmp;
}
public static void SelectionSort(E[] a)
{
int min;
for(int i=0;i<a.length-1; i++)
{
min=i;
for(int j=i+1; j<a.length; j++)
{
if(a[j].compareTo(a[min])<0)
min=j;
}
swap(a, min, i);
}
}
public String toString()
{
String s="";
int k=0;
int stampati=0;
Node<E> tmp=lista.getHead();
while(stampati!=3)
{
if(k==3|| k==5 ||k==7)
{
s+=tmp.getElement()+" ";
stampati++;
}
k++;
tmp=tmp.getNext();
}
return s;
}
}
public class SS7_003292
{
public static void main(String [] args)
{
programma("input.txt", "output.txt");
}
public static void programma(String input, String output)
{
FileReader reader=null;
BufferedReader buff=null;
PrintWriter out=null;
try{
reader=new FileReader("input.txt");
buff=new BufferedReader(reader);
out=new PrintWriter("output");
String s=buff.readLine();
int elements=0;
for(int i=0; i<s.length(); i+=2)
elements++;
Integer[] a=new Integer[elements];
int j=0;
for(int i=0; i<s.length(); i++)
a[j++]=Integer.parseInt(s.substring(i, i+1));
/*int k=0;
while(k<5)
{
collezione.deleteMin();
k++;
}*/
}
catch(IOException e1)
{
System.out.println("Error...I/O");
}
finally{
try{
reader.close();
buff.close();
out.close();
}
catch(IOException e2)
{
System.out.println("Error...it is not possible to close files");
}
}
}
}
Ma ottengo:
codice:
SS7_003292.java:210: non-static class E cannot be referenced from a static context
public static void swap(E[] a, int i, int j)
^
SS7_003292.java:217: non-static class E cannot be referenced from a static context
public static void SelectionSort(E[] a)
^
SS7_003292.java:212: non-static class E cannot be referenced from a static context
E tmp=a[i];
Cioč significherebbe piů o meno che la classe E non č staica e allora non puň essere usata in un metodo statico. Ma si tratta di un tipo generico, come faccio a rendere statico?
Rispondi quotando
) di leggere per bene tutto il malloppo di codice che hai scritto.
