[JAVA] Metodo per creare un albero

[orax841]

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:

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:

//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!

[orax841]

questa poi, se vi potesse essere utile, è la classe BTNode:

//Classe per definire i nodi utilizzati negli alberi
public class BTNode
{
    protected Object info;      // L'informazione nel nodo
    protected BTNode left;          // Left child
    protected BTNode right;         // Right child

    //------------------------------------------------
    //Costruttori del nodo
    public BTNode( )
    {
        left = right = null;
    }

    public BTNode( Object _info )
    {
        this( _info, null, null );
    }

    public BTNode( Object _info, BTNode _left, BTNode _right )
    {
        info  = _info;
        left  = _left;
        right = _right;
    }
    
    //Questi tre tipi di costruttori seguenti li utilizzo nel metodo createRoot() nel main per costruire
    //un albero partendo dall'espressione Infissa
    public BTNode (Object _info, Object infoLeft, Object infoRight)
    {
        info = _info;
        left = new BTNode(infoLeft);
        right = new BTNode(infoRight);
    }
    
    public BTNode (Object _info, Object infoLeft, BTNode _right)
    {
        info = _info;
        left = new BTNode(infoLeft);
        right = _right;
    }
    
    public BTNode (Object _info, BTNode _left, Object infoRight)
    {
        info = _info;
        left = _left;
        right = new BTNode(infoRight);
    }
    //------------------------------------------------
    
    //Metodo che torna l'informazione contenuto nel nodo
    public Object getInfo()
    {
        return info;
    }

    //Metodo che torna il figlio sinistro (BTNode)
    public BTNode getLeft()
    {
        return left;
    }

    //Metodo che torna il figlio destro (BTNode)
    public BTNode getRight()
    {
        return right;
    }

    //Metodo per settare il riferimento del figlio sinistro
    public void setLeft(BTNode n)
    {
        left = n;
    }

    //Metodo per settare il riferimento del figlio destro
    public void setRight(BTNode n)
    {
        right = n;
    }

    //Metodo utilizzato per la visita in un albero
    public void visit() 
    {
        System.out.print(info + " ");
    }
}

[orax841]

dimenticavo di dirvi che l'errore che mi viene dato in compilazione è:

compitoB.java:154: cannot resolve symbol
symbol  : method insertRandom (java.lang.String)
location: class BTNode
            root.insertRandom(libro);
                ^
1 error
>Exit code: 1

[alka]

Hai sbagliato sezione: sposto in Java.

Non inserire esortazioni nei titoli: tutti i quesiti sono urgenti allo stesso modo.

[LeleFT]

Non ho letto tutto il codice, non ne ho il tempo.
Ma il messaggio del compilatore è chiarissimo: la classe BTNode non è provvista di un metodo insertRandom() che prenda come unico parametro una stringa. Tu stai chiamando quel metodo su un oggetto che si chiama root che evidentemente è di tipo BTNode.

Scorrendo velocemente la classe BTNode, effettivamente, non c'è nessun metodo insertRandom().


Vedi tu come sistemare la cosa.


Ciao.