Ho provato a fare l'esercizio ma ho degli errori di compilazione....problemi con le interfacce, gli errori sono:

codice:
SS_003292.java: 172: > expected
class Albero<E> implements BSTSet<E extends Comparable>
                                   ^
SS7_003292.java: 172: <identifier> expected
class Albero<E> implements BSTSet<E extends Comparable>
Il codice, che avrŕ siciuramente molte cose fatte male č:


codice:
import java.util.*;
import java.io.*;

interface BSTSet<E extends Comparable> {
public int nodes ();
// ritorna il numero di nodi dell'albero
public int elements ();
// ritorna il numero complessivo di elementi di tipo E
public E getMinimum ();
// ritorna l'elemento piů piccolo contenuto nei nodi dell'albero
public SetNode<E> search (E e);
// ritorna il nodo contenente l'elemento e
public void insert (SetNode<E> node);
// aggiunge all'albero un nuovo nodo
public SetNode<E> getRoot ();
// ritorna la radice dell'albero
public SetNode<E>[] inorder();
// ritorna un array con gli insiemi dell'albero in ordine inorder
public E extractMinimum ();
// elimina e ritorna l'elemento piů piccolo dell'albero
}


//CLASSE NODO
class Node<E>
{
	private E element;
	private Node<E> next;
	
	public Node(E element)
	{
		this.element=element;
		next=null;
	}
	
	public void setElement(E element){this.element=element;}
	
	public E getElement(){return element;}
	
	public void setNext(Node<E> next){this.next=next;}
	
	public Node<E> getNext(){return next;}
	
}


//CLASSE LISTA
class LinkedList<E extends Comparable>
{
	private Node<E> head, tail;
	private final int CAPACITY;
	private int elementi;
	
	public LinkedList()
	{
		head=tail=null;
		CAPACITY=20;
		elementi=0;
	}
	
	public Node<E> getHead(){return head;}
	
	public Node<E> getTail(){return tail;}
	
	public int getElementi(){return elementi;}
	
	public void addNode(Node<E> node){
		assert elementi<CAPACITY;
		
		if(elementi==0){
		head=node;
		tail=node;
		}
		
		else if(tail.getElement().compareTo(node.getElement())<0){
				tail.setNext(node);
				tail=node;
			}
			
		else if(head.getElement().compareTo(node.getElement())>0){
			node.setNext(head);
			head=node;
		}
			
		else{
			boolean inserito=false;
			
				Node<E> current;
				Node<E> prev=head;
				
				for(current=head; current!=null && !inserito; current=current.getNext())
				{
					if(current.getElement().compareTo(node.getElement())>0){
						prev.setNext(node);
						node.setNext(current);
						inserito=true;
					}
					
					else prev=current;
				}
			}
			
		   elementi++;
		}
		
	public E removeHead(){
		
	if(elementi==0) return null;	
		Node<E> tmp=head;
		head=head.getNext();
		tmp.setNext(null);
		elementi--;
		return (E)tmp;
	}
	
	public String toString(){
	String s="";
	if(elementi==0)return s;
		Node<E> tmp=getHead();
		
		while(tmp!=null){
			s+=tmp.getElement()+" ";
			tmp=tmp.getNext();
		}
		
		return s;
	}
}

//CLASSE SETNODE
class SetNode<E>
{
	private E element;
	private SetNode<E> left;
	private SetNode<E> right;
	private SetNode<E> parent;
	
	public SetNode(E element)
	{
		this.element=element;
		left=null;
		right=null;
		parent=null;
	}
	
	//public void setElement(E element){this.element=element;}
	public void setParent(SetNode<E> parent){this.parent=parent;}
	
	public SetNode<E> getParent(){return parent;}
	
	public E getElement(){return element;}
	
	public boolean hasLeft(){return left!=null;}
	
	public boolean hasRight(){return right!=null;}
	
	public SetNode<E> getLeft(){
		if(hasLeft()) return left;
		return null;
	}
	
	public SetNode<E> getRight(){
		if(hasRight()) return right;
		return null;
	}
	
	public void setLeft(SetNode<E> left){this.left=left;}
	
	public void setRight(SetNode<E> right){this.right=right;}
}

class Albero<E> implements BSTSet<E extends Comparable>
{
	private SetNode<E> root;
	private int nodes;
	private int elements;
	private E[] albero;
	private int position;
	
	public Albero(int nodes)
	{
		root=null;
		this.nodes=nodes;
		elements=0;
		position=0;
		albero=(E[]) new Object[nodes];
		
	}
	
	public int getPosition(){return position;}
	
	public void setPosition(int p){position=p;}
	
	public int nodes(){return nodes;}
	
	public int elements(){return elements;}
	
	public E getMinimum (){
	if(nodes==0) return null;
		
	E element;
	SetNode<E> tmp=root;
	
	while(tmp.hasLeft())
		tmp=tmp.getLeft();
	
	return tmp.getElement().getHead();
	}
	
	public SetNode<E> search (E e){}
		
	public void insert (SetNode<E> node){
		if(size==0){
			root=node;
			root.setPosition(0);
		}
			
			
		else{
			SetNode<E> current=root;
			boolean inserito=false;
			
			while(!inserito){
				if(current.getElement().getHead().getElement().compareTo(node.getElement().getHead().getElement())<0)
				{
					if(!(current.hasRight())){
						current.setRight(node);
						array[current.getPosition()+1]=node;
						inserito=true;
					}
					
					else current=current.getRight();
				}
				
				else if(current.getElement().getHead().getElement().compareTo(node.getElement().getHead().getElement())>0)
				{
					if(!(current.hasLeft())){
						current.setLeft(node);
						array[current.getPosition()+1]=node;
						inserito=true;
					}
					else current=current.getLeft();
				}
			}
		}
		
	    nodes++;
	    elements+=node.getElement().getElementi();
	}
			
		
	public SetNode<E> getRoot(){return root;}
	
	public SetNode<E> getNodeMin(){
		if(size==0) return null;
		
		else{
			SetNode<E> tmp=root;
			while(tmp.hasLeft())
				tmp=tmp.getLeft();
			return tmp;
		}
	}
	
	public SetNode<E> getNodeMax(){
		if(size==0) return null;
		
		else{
			SetNode<E> tmp=root;
			while(tmp.hasRight())
				tmp=tmp.getRight();
			return tmp;
		}
	}
	
	public SetNode<E>[] inorder(){
		E[] array=(E[]) new Object[nodes];
		
		int i=0;
		
		SetNode<E> current=getNodeMin();
		SetNode<E> dad=current;
		
		while(current!=getNodeMax()){
			
			if(array[0]==null)
			array[i++]=current;
			
			if(current.getParent()!=null){
				
				current=current.getParent();
				dad=current;
				while(current.hasRight()){
					
					current=current.getRight();
					array[i++]=current;
				}
			
			current=dad;
			}
			
			else array[i]=current.getRight();
		}
		
		return array;
	}
	
	public String toString()
	{
		String s="";
		E[] array=inorder();
		
		for(int i=0; i<array.lenght; i++)
		s+=((LinkedList<E>)array[i]).toString();
	}
			
	public E extractMinimum(){
		if(size==0) return null;
		
		SetNode<E> tmp=root;
		E minimum=null;
		
		while(tmp.hasLeft())
			tmp=tmp.getLeft();
		
		minimum=tmp.getElement().removeHead();
		
		elements--;
		return minimum;
	}
}

public class SS7_003292
{
	FileReader reader=null;
	BufferedReader buff=null;
	PrintWriter out=null;
	StringTokenizer str;
	
	public void costruiscialbero(String input, String output)
	{
		try{
			reader=new FileReader(input);
			buff=new BufferedReader(reader);
			out=new PrintWriter(output);
		
			int nodi=0;
		
			while(buff.ready()){
			nodi++;
			buff.readLine();
			}
		
			System.out.println("Il numero di nodi č "+nodi);
		
			Albero<SetNode> albero=new Albero(nodi);
			
			SetNode<LinkedList> insieme=new SetNode();
		
			reader=new FileReader(input);
			buff=new BufferedReader(reader);
		
			while(buff.ready())
			{
				str=new StringTokenizer(buff.readLine(), " ");
				while(!(str.nextToken().equals(";"))){
				Node<E> nodo=new Node(str.nextToken());
				insieme.addNode(nodo);
				}
			
			albero.insert(insieme);
			}
		
		
			int a=0;
		
			while(a<5){
			albero.extractMinimum();
			a++;}
		
			out.print(albero.nodes()+" "+albero.elements()+" "+albero.getMinimum()+'\r'+'\n');
		
			}
			
			catch(FileNotFoundException e1)
			{
				System.out.println("Error...file not found");
			}
			
			catch(IOException e2)
			{
				System.out.println("Error...input/output");
			}
	}
	
	public static void main(String [] args)
	{
		long start=System.currentTimeMillis();
		costruiscialbero("input.txt", "SS7_003292.txt");
		long end=System.currentTimeMillis();
		System.out.println("Il tempo d'esecuzione č "+(end-start)+" ns");
	}
}
Non capisco cosa non gli piaccia...