Salve a tutti, stavo svolgendo un esercizietto di algoritmi che mi ha creato qualche perplessità, questa è la traccia:

restituisce true se e solo se il valore v compare alla stessa profondità nell’albero a e nell’albero b o se il valore v non appare in nessuno dei due alberi.
Allego la mia soluzione:

codice:
public static boolean valoreStessaProfondita(BinaryNode<Integer> a, BinaryNode<Integer> b, int v) {
    return verifica(a, b, v, 0);
}

private static boolean verifica(BinaryNode<Integer> a, BinaryNode<Integer> b, int v, int l) {
	if(a == null) return true;
	if(a.val == v && !stessaProfondita(b, v, l, 0) && conta(a, v) < 2) return false;
	return verifica(a.left, b, v, l + 1) || verifica(a.right, b, v, l + 1);
}

private static boolean stessaProfondita(BinaryNode<Integer> b, int v, int l1, int l2) {
	if(b == null) return false;
	if(b.val == v && l1 == l2) return true;
	return stessaProfondita(b.left, v, l1, l2+1) || stessaProfondita(b.right, v, l1, l2+1); 
}

private static int conta(BinaryNode<Integer> a, int x) {
	if(a == null) return 0;
	if(a.val == x) return 1 + conta(a.left, x) + conta(a.right, x);
	return conta(a.left, x) + conta(a.right, x);
}
La classe BinaryNode l'ho implementata io giusto per agevolarmi la notazione nei metodi, eccola qua :

codice:
public class BinaryNode<E> {
	public E val;
	public BinaryNode<E> left, right;
	public String toString() {
		return  val.toString();
	}
}
La ragione per cui ho verificato che non ci fosse più di una occorrenza nella condizione di uscita:
codice:
if(a.val == v && !stessaProfondita(b, v, l, 0) && conta(a, v) < 2) return false;
è perché ho pensato che il valore v in a potrebbe avere una seconda occorrenza che potrebbe essere allo stesso livello dell'altro albero.

Molto probabilmente è un algoritmo inefficiente ma mi interessa sapere se il mio ragionamento è corretto, grazie a tutti!