[JAVA] Strutturare meglio quest'albero

[guylmaster]

Salve a tutti,
sto facendo delle funzioni di data mining che servono per trovare delle rotte marittime frequenti su una mappa. Ora immaginandovi una mappa come un reticolo una rotta non è altro che una lista di celle. Se ho delle rotte frequenti che hanno ad esempio una partenza in comune posso rappresentarle tramite un albero.

Ho fatto però l'errore stilistico di rappresentare nella stessa struttura dati dell'albero la parte relativa ai pattern. Ovvero ho inserito nella struttura dell'albero una variabile relativa al supporto (con relativi set e get) ed un metodo che utilizzo altrove per espandere il frequentpattern. Adesso mi è stato chiesto di dividere queste due cose, ovvero la struttura dell'albero da una parte, ciò che riguarda i pattern da un'altra e mi sto un po' incasinando.

Se utilizzassi la composizione non andrebbe bene, non potrei fare una classe "frequentpattern" con dentro un albero, il float ed il metodo per estenderlo semplicemente perchè in un albero potrebbero esserci più tragitti, con più supporti. Pure volendola trattare al plurale diventerebbe difficile da trattare, considerando poi che potrei avere più alberi per rotte frequenti che non hanno pezzi in comune.

Avevo pensato allora ad un Albero_pattern che estende albero con quel float ed il metodo per estendere il pattern, ma anche qui mi sto perdendo perchè se voglio usare la stampa dell'albero ho bisogno di quel valore di supporto, quindi devo ridefinire la visita. Se voglio aggiungere un sottoalbero ma voglio memorizzarmi anche il valore di supporto allora devo ridefinire anche quello e finisce che ho ricreato la stessa identica classe albero ma con un nome differente.

Ora sarò fuso per l'orario e non ci arrivo, ma come posso fare per dividere in maniera ottimale le due classi?

Vi posto il codice sperando che la mia descrizione sia stata abbastanza accurata:

package Utility;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.TreeSet;

import Mappa.Cella;
import Mappa.Mappa_reale;
import Mining_albero.FrequentPatternMiner;
import Mining_albero.Item;
import Rotte.Mappa_grafica;

/**
*
* <p>La classe <b>Nodo</b> Rappresentazione di un albero n-ario semplificata </p>
*/
public class Albero {
	
	/**
	 * @attribue  Nodo radice
	 * Rappresenta il nodo radice dell'albero
	 */
//	Nodo radice;	
	Nodo padre;
	Nodo radice;//indica la radice del sotto albro
	LinkedList<Albero> figli;
	float support;
	public static int conta_pattern =0;
	
	
	LinkedList<Nodo> foglie;
	HashMap<Cella, Boolean> visitati;
	
	
	/**
	 * <p><b>Comportamento:</b>Costruttore dell'albero</p>
	 */
	public Albero (Nodo n)
	{
		this.radice = n;		
		figli=new LinkedList<Albero>();
		padre=null;
		//attuale=n;
		foglie=new LinkedList<Nodo>();
		visitati=new HashMap<Cella, Boolean>();
		n.setAlbero(this);
	}
	
	
	/**
	 * <p><b>Comportamento:</b>Ritorna il nodo padre</p>
	 * @return Nodo
	 * @params nodo
	 */
	public Nodo get_padre()
	{
		return padre;
	}
	/**
	 * <p><b>Comportamento:</b>Ritorna il nodo radice</p>
	 * @return Nodo
	 */
	public Nodo get_radice()
	{
		return radice;
	}
	
	public void set_radice(Nodo radice)
	{
		this.radice=radice;
		//this.attuale=radice;
	}
	
	public void set_padre(Nodo padre)
	{
		this.padre=padre;
	}
	
	public void aggiungiSottoAlbero(Albero figlio){
		figlio.updateNodeId(this);
		figlio.set_padre(this.radice);
	//	figlio.set_padre(this.attuale);

		//System.out.println(figlio.radice);
		//System.out.println(figlio.padre);
		//System.out.println(figlio.attuale);
		figli.add(figlio);
	}
	private void updateNodeId(Albero a){
		this.radice.a=a;
		for(Albero tree:figli)
			tree.updateNodeId(a);
		
	}
	
	
	
	/**
	*<p><b>Comportamento:</b> assegna al membro support il parametro della procedura </p>
	*@param support (valore di supporto del pattern)
	*/
	public void setSupport(float support)
	{
		this.support = support;
	}
	
	
	/**<p><b>Comportamento:</b> restituisce il membro support</p>
	*@return float*/
	public float getSupport()
	{
		return support;
	}
	
	public int getNfigli()
	{
		return  figli.size();
	}
	
	public LinkedList<Albero> getfigli()
	{
		return  figli;
	}
	
	public boolean foglia(Nodo n)
	{
		if(figli.size()==0)
			return true;
		else return false;
	}
	
	
	/**
	*<p><b>Comportamento:</b> restituisce l'item della radice</p>
	*@param index (posizione in fp)
	*@return Item
    */
	public Item getItem()
	{
		return radice.getItem();
	}
	
	public void expandFrequentPatterns(HashMap<Cella, TreeSet<Short>> HashMap_item, float minSup)
	{
		Cella c=radice.getItem().getcella();
		ArrayList<Cella> vicini = Mappa_reale.getVicini(c);
		
		
		for (int h = 0; h < vicini.size(); h++) 
		{
			if(!visitati.containsKey(vicini.get(h)))
			{
				//Se il vicino non contiene valori vuoti
				if(HashMap_item.get(vicini.get(h)) != null)
				{
					visitati.put(vicini.get(h), true);
					Item estendi = new Item(vicini.get(h));
					//System.out.println("estendi: "+estendi);
					estendi.copyAllShip(HashMap_item.get(vicini.get(h)));
					
					
					Nodo n=new Nodo(estendi);
					Albero figlio= new Albero(n);
//System.out.println(figlio.attuale);	
					figlio.setSupport(FrequentPatternMiner.computeSupport(radice.getItem(),n.getItem()));
					if(figlio.getSupport()>=minSup)
					{
						this.toString();
						this.aggiungiSottoAlbero(figlio);
						//System.out.println(this.toString());
						figlio.expandFrequentPatterns(HashMap_item, minSup);
					}
					//System.out.println(this);
					
				}
			}
		
		}
	}
	
	void  visita( LinkedList<String> foglie,String currentPattern)
	{
		//foglie=new LinkedList<Nodo>();
		currentPattern+= radice.getItem()+"   Supporto : "+"["+this.getSupport()+"]  | " ;
		if(!foglia(radice))
		{
			//for(int i=0;i<n.a.getNfigli();i++)
			for(Albero figlio:figli)
			{
				figlio.visita(foglie,currentPattern);
			}
		}
		else
		{
			foglie.add(currentPattern);
		}
	}
	
	
	public String toString()
	{
		LinkedList<String> patterns=new LinkedList<String>();
		String currentPattern="";
		String albero_visualizzato="";
		this.visita(patterns,currentPattern);
		//Mappa_grafica.stampa_mappa(FrequentPatternMiner.data.getMappa(), rotta);
		for(String pattern:patterns)
			albero_visualizzato+=pattern+"\n";
		
		return albero_visualizzato;
	}
	
	public int contaPatterns()
	{
		LinkedList<String> patterns=new LinkedList<String>();
		String currentPattern="";
		String albero_visualizzato="";
		this.visita(patterns,currentPattern);
		//Mappa_grafica.stampa_mappa(FrequentPatternMiner.data.getMappa(), rotta);
		
		
		return patterns.size();
	}
	
	public int  visita2()
	{
		int N_nodi=1;
		if(!foglia(radice))
		{
			for(Albero figlio:figli)
			{
				N_nodi+=figlio.visita2();
			}
		}
		return N_nodi;
	}
	
	public int ContaNodiAlbero()
	{	
		return visita2();
	}
		

}

mentre la classe nodo è questa:

package Utility;

import Mining_albero.Item;


/**
*
* <p>La classe <b>Nodo</b> Rappresenta il nodo di un albero n-ario </p>
*/
public class Nodo{
	Albero a;
	Item info;
	
	
	public Nodo(Item new_item)
	{
		this.info=new_item;
		a=null;
	}

	public void setAlbero(Albero a)
	{
		this.a=a;
	}
	public Albero getAlbero(){
		return a;		
	}
	
	public Item getItem(){
		return info;
	}

	public int compareTo(Item o) {
		if(this.info.compareTo2(o)==0)
			return 0;
		else
			return -1;
	}
	
	public String toString()
	{
		return info.toString() + " radice albero: "+a.radice.getItem();
	}
}

Quello che dovrei tirare fuori sono "support" con relativi get e set ma anche "expandFrequentPatterns".

So che solitamente ciò che si va ad usare come contenitore è la rappresentazione del nodo, ma qui la cosa è più complessa perchè un frequentpattern corrisponde ad un cammino dell'albero, né ad un nodo né ad un intero albero.

Quello che faccio per ora è arrivato ad un certo sottoalberlo associarli il valore del supporto fino a quel livello. In pratica se nel nodo a ho 2 navi, e nel suo figlio b ho solo 1 di quelle due navi, allora nel nodo a il supporto sarà 2 nel nodo b il supporto diventerà 1.

Una mezza idea potrebbe essere inscatolare in un frequentpattern il nodo foglia ed associarli il supporto finale (potrei ricostruirmi l'intero pattern scorrendomi i padri) però così mi perderei i supporti intermedi.

Ogni idea o consiglio (compreso quello di non scrivere più di notte ) è ben accetto.