Altura y Tipo de arbol (java)

El problema es el siguente:

Realizar una función recursiva que reciba como parámetro de entrada un BinaryTree y que devuelva la altura del árbol y un String que podrá tomar cuatro valores: “V” (Vacío), “CO” (Completo), “CA” (Casi Completo) u “O” (Otros), en función del tipo del árbol.
Notas:
El árbol sólo se puede recorrer una vez.
Se definirá la altura de un árbol vacío como - 1, y la de un árbol con un elemento como 0.
Se supone implementada una función max(intege, integer) que devuelve el máximo entre los enteros que se le pasan como parámetros de entrada.

Una posible solucion en java es la siguente:


public doble alturaYTipodeArbol2(Nodo b){
doble izq=new doble(),der=new doble(),res=new doble();

if(b.isEmpty()){
res.a=-1;
res.tipo="V";
} else if(b.isLeaf()){
res.a=0;
res.tipo="CO";
}else{
if(b.left()!=null){
izq=alturaYTipodeArbol(b.left());}
if(b.right()!=null){
der=alturaYTipodeArbol(b.right());}
res.a=max(izq.a,der.a)+1;
if(b.left()==null){
res.tipo="O";}
else if(b.right()==null){
if(izq.a==0){
res.tipo="CA";}
else{
res.tipo="O";}}
else if(izq.a==der.a && izq.tipo.equals("CO") && der.tipo.equals("CO")){
res.tipo="CO";}
else if((izq.tipo.equals("CO") && der.tipo.equals("CA") && izq.a==der.a)|| ((izq.tipo.equals("CO") || izq.tipo.equals("CA"))&& der.tipo.equals("CO") && izq.a==der.a+1)){
res.tipo="CA";{
else {
res.tipo="O";}
}
return res;
}
public int max(int a, int b){
int aux;
if(a < b){
aux=b;}
else{
aux=a;}
return aux;
}


Monticulo de máximos a lista en orden inverso (java)

El problema es el siguiente:


Realice un algoritmo que partiendo de un montículo de máximos, representado con un BinaryTree, devuelva una lista de los elementos de dicho montículo ordenados de mayor a menor. Los elementos del montículo son enteros.
NOTA: Se pueden utilizar estructuras auxiliares.

Para quién llame al montículo de máximos de otra forma, decir que es un árbol (binario en éste caso) en el que cada nodo es mayor o igual que sus hijos.

Dicho esto pondré la primera solucion en JAVA:


public LinkedList monticuloAlistaOrdenInverso2(BinaryTree b){
LinkedList sol = new LinkedList();
LinkedList laux = new LinkedList();
BinaryTree a;
int max, imax=0;
if(!b.isEmpty()){
laux.add(b);
a=b;
while(laux.size() > 0){
sol.add(a.getRoot());
laux.remove(imax);
if(a.left()!= null){
laux.add(a.left());}
if(a.right()!= null){
laux.add(a.right());}
max=Integer.MIN_VALUE;

for(int i=0; i < laux.size();i++){
if(max < laux.get(i).getRoot()){
max=laux.get(i).getRoot();
imax=i;
}
}
if(!laux.isEmpty()){
a=laux.get(imax);}
}
}
return sol;
}


Otra solución para montículos que no tengan valores repetidos es la siguiente:


public LinkedList monticuloAlistaOrdenInverso(BinaryTree b){
LinkedList l = new LinkedList();
TreeSet s = new TreeSet();
Object o;
Iterator i=b.iterator();
while(i.hasNext()){
s.add(i.next());
}
while(!s.isEmpty()){
o=s.last();
l.add(o);
s.remove(o);
}
return l;
}