Salve..ho un problema con la creazione di un albero e più precisamente, il programma mi da' un errore dovuto al fatto che i metodi insertRandom() e insert() contenuti nella classe BSTree sono stati creati per gestire interi. Qualcuno potrebbe sistemarli per gestire oggetti tipo stringhe?
questo è il main:
codice:
import java.io.*;
public class compitoB implements Serializable
{
    public static void main(String [] args)throws Exception
    {
        //creiamo il file contenente le informazioni dei libri
        String nomeFile = "libri.dat";
        scriviFile(nomeFile);
        
        //=============================================================//
        //carichiamo le informazioni relative ad ogni libro in un opportuno oggetto
        caricaInformazioni(nomeFile);
        
        //leggere il file di oggetti e inserire tali oggetti in una struttura dati dinamica
        Coda codaLibri = new Coda();
        leggiFile(nomeFile, codaLibri);
        codaLibri.printCoda();
        
        
        //individuare il nome e cognome dell'autore il maggior numero di libri(e relativo numero)
        /*leggiFile(nomeFile,codaLibri);
        String autoreMaxLibri = cercaAutoreMaxLibri(codaLibri);
        System.out.println("\n\nAutore che ha scritto più libri: "+autoreMaxLibri);*/
        
    }
    //metodo per generare i titoli dei libri
    public static String titoliLibri(int max)
    {
        String libro = " ";
        libro = titoliLibriAux(libro, max);
        System.out.println("Libro:\t"+libro);
        return libro;
    }
    public static String titoliLibriAux(String s, int max)
    {
        int cont=0;
        String [] lettere = {"a","b","c","d","e","f","g","h","i","l","m","n","o","p","q","r","s","t","u","v","z"};
        int maxNumLibri = max;
        for(int i=0; i<maxNumLibri; i++)
        {
            cont=0;
            if(cont!=4)
            {
                s += lettere[(int)(Math.random()*21)];
                cont++;
            }
        }
        return s;
    }
    public static void scriviFile(String nomeFile) throws IOException
    {
        ObjectOutputStream Oout;
        try
        {
            Oout = new ObjectOutputStream(new FileOutputStream(nomeFile));
        }
        catch(IOException exc)
        {
            System.out.println("Si è verificato l'errore:"+exc);
            return;
        }
        
        int libriInMagazzino = (int)(Math.random()*500); //numero di libri in magazzino
        int numMax = libriInMagazzino;
        libri lbr = null;
        String stringaLibro = " ";
        for(int i=0; i<libriInMagazzino; i++)
        {
            stringaLibro = titoliLibri(numMax);
            lbr = new libri(stringaLibro);
            try
            {
                Oout.writeObject(lbr);//scriviamo nel file gli oggetti(i libri)
            }
            catch(IOException e)
            {
                System.out.println("Si è verificato l'errore:"+e);
            }
        }
        Oout.close();
    }
    public static void leggiFile(String nomeFile, Coda codaLibri) throws IOException
    {
        BSTree alberoLibri;
        
        ObjectInputStream Oin = null;
        
        try
        {
            Oin = new ObjectInputStream(new FileInputStream(nomeFile));
        }
        catch(FileNotFoundException e)
        {
            System.out.println("Si è verificato l'errore:"+e);
        }
        
        if(Oin == null)
            return;
        
        String libro = " ";
        libri tmp = null;
        boolean fine = false;
        while(!fine)
        {
            try
            {
                tmp=(libri)Oin.readObject();
                libro = tmp.getTitolo();
                alberoLibri = new BSTree((BTNode)createTree(libro));
                
                codaLibri.Enqueue(alberoLibri);//l'albero che contiene i nomi dei libri viene inserito nella coda(struttura dinamica)
            }
            catch(EOFException e)
            {
                System.out.println("==========Fine file=============");
                fine=true;
            }
        }
        Oin.close();
        return;
    }
    public static String caricaInformazioni(String nomeFile)throws Exception
    {
        //int id;
        //String tipo,titolo;
        //char cognomeA,nomeA;
        ObjectInputStream lettura = new ObjectInputStream(new FileInputStream("libri.dat"));
        ObjectOutputStream fileOut = null;
        //String info;
        try
        {
            fileOut = new ObjectOutputStream(new FileOutputStream("elencoInfoPerOgniLibro.txt"));
            for(int i=0; i<nomeFile.length(); i++)
            {
                fileOut.writeObject(lettura.readObject());
            }
            fileOut.flush();
            fileOut.close();
        }
        catch(Exception e)
        {
            System.out.println(e);
        }
    }
    
    //metodo per creare l'albero
    public static BTNode createTree(String libro)throws Exception
    {
        BTNode root = null;
        
        while(libro!=null)
        {
            //dovrei inserire nell'albero le informazioni dei libri contenute in un magazzino
            //le informazioni sono:ID_libro,tipologia,titolo,cognomeAutore,nomeAutore
            //tali info le ho già create in una classe libri distinta
            root.insertRandom(libro);
        }
        return root;
    }
}
questa è la classe BSTree:
codice:
//Classe per definire gli alberi
public class BSTree
{
    protected BTNode root;
        
    //------------------------------------------------
    //Costruttorio Albero binario
    public BSTree()
    {
        root = null;
    }
    
    public BSTree(BTNode r)
    {
        root = r;
    }
    //------------------------------------------------
    
    //Metodo che restituisce un boolean con valore true se l'albero è vuoto, false altrimenti
    public boolean isEmpty()
    {
        return (root == null);
    }
    
    //Metodo che cancella tutti gli elementi dell'albero
    public void clear()
    {
        root = null;
    }
    
    //Metodo che restituisce la radice dell'albero
    public BTNode getRoot()
    {
        return root;
    }
    
    //Metodo per settare la radice dell'albero
    public void setRoot(BTNode _root)
    {
        root = _root;
    }
    
    //------------------------------------------------    
    //metodi per inserire elementi nell'albero
    public void insert(Comparable x)
    {
        root = insert(x, root);
    }
    
    public BTNode insert(Comparable x, BTNode t)
    {
        if(t==null)
            t = new BTNode(x);
        else
            if(x.compareTo(t.getInfo())<0)
                t.left = insert(x, t.left);
            else
                if(x.compareTo(t.getInfo())>0)
                    t.right = insert(x, t.right);
                else
                    ;
        return t;
    }
    
    public void insertRandom(Object x)
    {
        root = insertRandom(x, root);
    }
    
    public BTNode insertRandom(Object x, BTNode t)
    {
        if(t==null)
            return new BTNode(x);
        
        if(Math.random()<.5)
            t.left = insertRandom(x, t.left);
        else
            t.right = insertRandom(x, t.right);
        
        return t;
    }
    //------------------------------------------------
    
    //------------------------------------------------
    //Metodi di ricerca nell'albero
    public BTNode searchMin()
    {
        return searchMin(root);
    }
    
    public BTNode searchMin(BTNode t)
    {
        if(t != null)
            while(t.left != null)
                t = t.left;
            
        return t;
    }
    
    public BTNode searchMax()
    {
        return searchMax(root);
    }
    
    public BTNode searchMax(BTNode t)
    {
        if(t != null)
            while (t.right != null)
                t = t.right;
            
        return t;
    }
    
    public BTNode search(Comparable x)
    {
        return search(x, root);
    }
    
    public BTNode search(Comparable x, BTNode t)
    {
        if(t==null)
            return null;
        else
            if(x.compareTo(t.getInfo())<0)
                return search(x, t.left);
            else
                if(x.compareTo(t.getInfo())>0)
                    return search(x, t.right);
                else
                    return t;
    }
    //------------------------------------------------

    //Metodo che restituisce l'altezza dell'albero
    public int getHeight()
    {
        if(isEmpty())
            return -1;
        return getHeightAux(root);
    }
    
    public int getHeightAux(BTNode t)
    {
        if(t == null)
            return 0;
        
        if(t.left == null && t.right == null)
            return 0;
        
        if(getHeightAux(t.left) < getHeightAux(t.right))
            return (1+getHeightAux(t.right));
        else
            return (1+getHeightAux(t.left));
    }
    
    //------------------------------------------------    
    //Metodi di vista dell'albero
    public void preorder()
    {
        preorder(root);
    }
    
    public void preorder(BTNode t)
    {
        if(t!=null)
        {            
            t.visit();
            preorder(t.left);
            preorder(t.right);
        }
    }
    
    public void inorder()
    {
        inorder(root);
    }
    
    public void inorder(BTNode t)
    {
        if(t!=null)
        {
            inorder(t.left);
            t.visit();
            inorder(t.right);
        }
    }
    
    public void postorder()
    {
        postorder(root);
    }
    
    public void postorder(BTNode t)
    {
        if(t!=null)
        {
            postorder(t.left);
            postorder(t.right);
            t.visit();
        }
    }
    //------------------------------------------------

    //Metodo per stampare l'albero in una forma grafica
    public void StampaGrafica()
    {
        BTNode p = root;
        if(p!=null)
            StampaGrafica(p,0);
        else
            System.out.println ("Albero Vuoto");
    }
    
    protected void StampaGrafica(BTNode subroot, int livelloAttuale)
    {
        if(subroot==null)
            return;
        StampaGrafica(subroot.right, livelloAttuale+1);
        for(int liv = livelloAttuale; liv>0; liv--)
            System.out.print ("\t");
        System.out.println (subroot.getInfo());
        StampaGrafica(subroot.left, livelloAttuale+1);
    }
    
    //Metodo che ridefinisce il toString() per stampare i valori dell'albero al posto dell'indirizzo
    //In questo particolare caso lo uso per effettuare una stampa Inorder
    public String toString()
    {
        return "\n"+leggiAlbero()+"\n";
    }
    
    public String leggiAlbero()
    {
        return leggiAlberoAux(root);
    }
    
    public String leggiAlberoAux(BTNode p)
    {
        String s = "";
        if(p!= null)
        {
            s += leggiAlberoAux(p.getLeft());
            s += p.getInfo();
            s += leggiAlberoAux(p.getRight());
        }
        return s;
    }
}
AIUTATEMI PER FAVORE, è URGENTISSIMO.
GRAZIE!