The next step, BinaryTree in Java. part IV

This tutorial is advancing a bit slowly because i have not more free time, but now you can watch a pre-end code.

In the part V i will explain you the InOrder, PreOrder, PosOrder method for construct paths which returns us all the BinaryTree's nodes.

note: The class imported "Lista" can be replaced by ArrayList or LinkedList from java.util

import zapi.list.Lista;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.*;

public class BinaryTree implements Tree {
// ATRIBUTOS
/** Referencias al nodo raiz del arbol */
private Nodo root = null;
/** Informa del número de nodos que tiene el arbol */
private int elementCount = 0;
/** Informa del número de modificaciones estructurales realizadas
* en el arbol desde que se construyo. Sólo aumenta, nunca disminuye */
private int modCount = 0;

// CLASES INTERNAS
/** Clase interna Nodo para implementar el arbol binario.
* Con esta clase se modela los datos que se almacenan en el arbol*/
private class Nodo implements Cloneable {
private Object info;
private Nodo left,right;
/** Constructor con parametros */
public Nodo(Object info, Nodo left, Nodo right) {
super();
this.info = info;
this.left = left;
this.right = right;
}
/** Constructor sin parametros */
public Nodo() {
super();
this.info = null;
this.left = null;
this.right = null;
}
/** Clonador del nodo, al clonar el nodo raiz se clona el arbol completo */
public Object clone() throws CloneNotSupportedException {
Nodo clon=(Nodo)super.clone();
clon.info=getClone(info);
if(left!=null)
clon.left=(Nodo)left.clone();
if(right!=null)
clon.right=(Nodo)right.clone();
return clon;
}
/** Devuelve un clon del objeto recibido como parametro */
private Object getClone(Object o) throws CloneNotSupportedException {
Object clon = null;
try {
Method method = o.getClass().getMethod("clone", null);
clon = method.invoke(o, null);
}
catch (IllegalAccessException ex1) {
throw new CloneNotSupportedException("El metodo clone no es publico (" + ex1.toString() + ")");
} catch (NoSuchMethodException ex2) {
throw new CloneNotSupportedException( "El objeto no implementa la interfaz Cloneable (" + ex2.toString() + ")");
}
catch (InvocationTargetException ex3) {
throw new CloneNotSupportedException( "Error inesperado al llamar al metodo clone (" + ex3.toString() + ")");
}
return clon;
}
}

// METODOS PROPIOS DE LA CLASE BINARYTREE
/** Comprobar que se trata de un nodo hoja del arbol binario */
public boolean isLeaf (){
boolean b=false;
if ( this.isEmpty() == true)
throw new NoSuchElementException ("No hay arbol");
if ((root.left==null)&&(root.right==null))
b=true;
return b;
}
/** Comprueba que el arbol este vacío */
public boolean isEmpty(){
boolean b=false;
if (root==null)
b=true;
return b;
}
/** Añade al arbol otro subarbol como hijo izquierdo o hijo derecho. */
public void set (boolean left, BinaryTree t){
if (t==null)
throw new NullPointerException ("No es posible añadir un arbol vacío");
if ( t.isEmpty() == true)
throw new NoSuchElementException
("No hay arbol");
if (left==true){
root.left=t.root;
elementCount=elementCount+t.size();
}
else
{
root.right=t.root;
elementCount=elementCount+t.size();
}
}
/** Elimina el hijo izquierdo o derecho del arbol */
public void remove (boolean left){
if (this.isEmpty()==true)
throw new NoSuchElementException ("No es posible eliminar elementos");
if (left==true)
root.left=null;
else
root.right=null;
modCount++;
}
/** Sustituye la raiz del arbol por el elemento nuevo */
public void setRoot (Object elem){
if (elem==null)
throw new NullPointerException ("No es posible añadir un elemento a la raíz");
if (this.isEmpty()==true)
throw new NoSuchElementException ("No hay arbol");
root.info=elem;
elementCount++;
modCount++;
}
/** Devuelve la información contenida en la raiz del arbol */
public Object getRoot()
{
if (this.isEmpty()==true)
throw new NoSuchElementException ("No hay arbol");
return this.root.info;
}
/** Devuelve el subarbol izquierdo */
public BinaryTree left()
{
BinaryTree b;
if ((this.isEmpty()==true)||(root.left==null))
throw new NoSuchElementException ("No hay arbol");
b=new BinaryTree();
b.setRoot(this.root.left.info);
//Establecemos la raiz del arbol auxiliar, usando la rama izquierda
b.root.left=this.root.left.left; //Rama izquierda del arbol auxiliar
b.root.right=this.root.left.right; //Rama derecha del arbol auxiliar
return b;
}
/** Devuelve el subarbol derecho */
public BinaryTree right(){
BinaryTree b;
if ((this.isEmpty()==true)||(root.right==null))
throw new NoSuchElementException ("No hay arbol");
b=new BinaryTree();
b.setRoot(this.root.right.info);
//Establecemos la raiz del arbol auxiliar, usando la rama derecha
b.root.left=this.root.right.left; //Rama derecha del arbol auxiliar
b.root.right=this.root.right.right; //Rama izquierda del arbol auxiliar
return b;
}
/** Elimina todos los elementos del arbol */
public void clear (){
elementCount=0;
modCount++;
root=null;
}
/** Indica el tamaño del arbol */
public int size (){
return
elementCount-1;
}
/** Dice si un nodo es igual a otro pasado por parametros */
public boolean equals (Object tree){
if (tree == null)
return false;
if (!(tree instanceof BinaryTree))
return false;
BinaryTree bt = (BinaryTree)tree;
if (bt.size()!=this.size())
return false;
Iterator it1=this.iterator();
Iterator it2=bt.iterator();
boolean igual= true;
while (it1.hasNext()&&igual){
if (!(it1.next().equals(it2.next())))
igual=false;
}
return igual;
}
}