Newsgroup: it.comp.java
Titolo: Aiuto! Sto impazzendo.

Vi piace programmare?
Io sto pensando di cambiare lavoro: da 2 giorni sto impazzendo per questa
funzione contenuta in un albero generico bilanciato e pesato per rami ma
mi ci sono problemi che non riesco proprio a risolvere.
Se non avete paura del codice potete darmi una mano altrimenti grazie
comunque per la pazienza....
	/**
	 * La funzione opera la rimozione del nodo il cui indice e' specificato come argomento. Se il nodo viene effettivamente eliminato ritorna true altrimenti (il nodo non esiste) ritorna false;
	 * 
	 * @param index
	 *            indice del nodo da eliminare.
	 * @return true se il nodo esiste, false se il nodo non esiste.
	 */
	public boolean remove(long index) {
		// Ora cerco la replacing del ramo piu` lungo.
		SimpleNode trans = get(index), replacing, trans1;
		if(trans == null) return false;
 
		if(trans.leftchild==null && trans.rightchild==null) {
			if(trans == trans.phather.rightchild) {
				trans.phather.rightchild=null;
			}
			else trans.phather.leftchild=null;
			return true; //Il nodo e` stato correttamente rimosso.
		}
		// Ora cerco la replacing adeguata del ramo piu` lungo sottostante a quello da sostituire in questo modo si contribuisce, anche se poco, a mantenere
 bilanciato l'albero.
		replacing = trans;
		if(replacing.rightElNumber >= replacing.leftElNumber &&
		replacing.rightchild != null) {
			replacing = replacing.rightchild;
			while(replacing.leftchild != null) {
				replacing = replacing.leftchild;
			}
			}
		else if(replacing.leftchild != null) {
			replacing = replacing.leftchild;
			while(replacing.rightchild != null) {
				replacing = replacing.rightchild;
			}
			}
		}
		/*Ora le operazioni da fare in sequenza dovranno essere le seguenti:
		 * -se il replacing non ha figli si svincola semplicemente dall'albero.
		 * -se il replacing ha un figlio, unico per definizione, questo va
		 inserito al posto del replacing che rimane cosi` svincolato * -si
		 aggiornano i pesi al di sopra del replacing (decremento unitario). *
		 -si sostituisce il replaced con il replacing ereditando anche i pesi. *
		 -TUTTO OK
		 */
		//Rimozione replacing dall'albero
		if(replacing.rightchild == null && replacing.leftchild == null) {//replacing senza figli
			// Caso in cui la replacing sia un nodo "destro".
			if(replacing == replacing.phather.rightchild) {
				replacing.phather.rightchild = null;
			}
			// Caso in cui la replacing sia un nodo "sinistro".
			else {
				replacing.phather.leftchild = null;
			}
		}
		else if(replacing.rightchild!=null){//Caso in cui il replacing abbia un figlio a destra.
			//A questo punto il replacing puo` essere solo un figlio sinistro.
			replacing.phather.leftchild = replacing.rightchild;
		}
		else {
			//A questo punto il replacing puo` essere solo un figlio destro.
			replacing.phather.rightchild = replacing.leftchild;
		}
 
		// Correzione elnumber dei nodi sovrastanti il nodo replacing.
		trans1 = replacing;
		while(!trans1.isRootNode) {
			if(trans1 == trans1.phather.rightchild) {
				trans1.phather.rightElNumber--;
				// if(trans.phather.rightElNumber < 0) System.err.println("SimpleNode: qualcosa non va nellaggiornamento degli elNumber nella funzione remove().");
			}
			else {
				trans1.phather.leftElNumber--;
				// if(trans.phather.leftElNumber < 0) System.err.println("SimpleNode: qualcosa non va nellaggiornamento degli elNumber nella funzione remove().");
			}
			trans1 = trans1.phather;
		}
		replaceNode(trans, replacing);
		trans = null;
		replacing = null;
		return true;
	}
 
	/**
	 * Da usare con consapevolezza in quanto il sostituto eredita i pesi dal sostituito,
	 * inoltre gli eventuali figli del sostituto vengono persi per sempre.
	 * @param replaced
	 * @param replacing
	 */
	private void replaceNode(SimpleNode replaced, SimpleNode replacing) {
		if(replaced == replaced.phather.rightchild) {
			replaced.phather.rightchild = replacing;
		}
		// Caso in cui il nodo da cancellare sia un nodo "sinistro".
		else {
			replaced.phather.leftchild = replacing;
		}
		replacing.leftchild = replaced.leftchild;
		replacing.rightchild = replaced.rightchild;
		replacing.rightElNumber = replaced.rightElNumber;
		replacing.leftElNumber = replaced.leftElNumber;
		replacing.phather = replaced.phather;
	}

 
Ma scusa, questo codice chi l'ha scritto, tu o qualcun'altro? Che vuol 
dire "Da usare con consapevolezza" ? Prova a spegnere il computer, 
prendere carta e penna e ragionare su cosa ti serve, decomponi 
l'algoritmo e le strutture dati in elementi più semplici e...riscrivi da 
capo!
Ciao e torna con novità più incoraggianti!