Salve a tutti questo è il mio problema:

Scrivere un metodo RICORSIVO
BinaryTree Copia (Position p)
che invocato su un albero binario T fornisca in output (costruisca) un albero binario che è la copia (clone) del sottoalbero di T radicato nel nodo di posizione p. Occorre usare i metodi dell’interfaccia BinaryTree.

I metodi dell'interfaccia BinaryTree sono:

package tree;
import list.*;
import iterator.*;
public class LinkedBinaryTree implements BinaryTree{

private Position root;
private int size;

public LinkedBinaryTree(){
root=null;
size=0;
}

public int size(){
return size;
}

public boolean isEmpty(){
return (size==0);
}

//ritorna true se il nodo v ha almeno un figlio destro o un figlio sinistro
public boolean isInternal(Position v)throws InvalidPositionException{
checkPosition(v);
return (hasLeft(v)||hasRight(v));
}

//ritorna true se il nodo non è un nodo interno
public boolean isExternal(Position v)throws InvalidPositionException{
return !isInternal(v);
}


public boolean isRoot(Position v)throws InvalidPositionException{
checkPosition(v);
return(v==root);
}

public boolean hasLeft(Position v)throws InvalidPositionException{
BTPosition vv=checkPosition(v);
return (vv.getLeft()!=null);
}

public boolean hasRight(Position v)throws InvalidPositionException{
BTPosition vv= checkPosition(v);
return (vv.getRight()!=null);
}

public Position root()throws EmptyTreeException{
if(root==null)
throw new EmptyTreeException("L'albero è vuoto, non ha root");
return root;
}

public Position left(Position v)
throws InvalidPositionException, BoundaryViolationException{
if(!hasLeft(v))
throw new BoundaryViolationException("Non ha figlio sinistro");
return((BTPosition)v).getLeft();
}

public Position right(Position v)
throws InvalidPositionException, BoundaryViolationException{
if(!hasRight(v))
throw new BoundaryViolationException("Non ha figlio destro");
return((BTPosition)v).getRight();
}

public Position parent(Position v)
throws InvalidPositionException, BoundaryViolationException{
if(isRoot(v))
throw new BoundaryViolationException("La radice nn ha padre");
return((BTPosition)v).getParent();
}

public Iterator children(Position v)throws InvalidPositionException{
List children = new NodeList();
if(hasLeft(v))children.insertLast(left(v));
if(hasRight(v))children.insertLast(right(v));
return children.elements();
}

public Iterator positions(){
List positions= new NodeList();
if(size!=0)
inorderPositions(root(),positions);
return positions.elements();
}

public Iterator elements()throws InvalidPositionException{
Iterator positer=positions();
List elementi= new NodeList();
while(positer.hasNext())
elementi.insertLast(((Position)positer.next()).ele ment());
return elementi.elements();
}
//controlla se v è una posizione valida per l'albero
protected BTPosition checkPosition(Position v)
throws InvalidPositionException {
if (v == null || !(v instanceof BTPosition))
throw new InvalidPositionException("Position non valida");
return (BTPosition) v;
}

protected void inorderPositions(Position v, List pos)
throws InvalidPositionException {
if (hasLeft(v))
inorderPositions(left(v), pos); // ricorsione su figlio sinistro
pos.insertLast(v);
if (hasRight(v))
inorderPositions(right(v), pos); // ricorsione su figlio destro
}


public Object replace(Position v, Object o)
throws InvalidPositionException {
BTPosition vv = checkPosition(v);
Object temp = v.element();
vv.setElement(o);
return temp;
}

protected BTPosition createNode(Object elem, BTPosition parent, BTPosition left, BTPosition right){
return new BTNode(elem, parent, left, right);
}

public Position insertLeft(Position p, Object o)throws InvalidPositionException{
if(hasLeft(p))throw new InvalidPositionException
("Non puoi inserire un figlio sinistro, c'è già");
BTPosition dato= checkPosition(p);
BTPosition nuovo= createNode(o,dato,null,null);
dato.setLeft(nuovo);
size++;
return nuovo;
}

public Position insertRight(Position p, Object o)throws InvalidPositionException{
if(hasRight(p))throw new InvalidPositionException
("Il nodo ha già un figlio destro");
BTPosition dato= checkPosition(p);
BTPosition nuovo= createNode(o, dato,null, null);
dato.setRight(nuovo);
size++;
return nuovo;
}

public Position addRoot(Object o)throws NotEmptyTreeException{
if(!isEmpty()) throw new NotEmptyTreeException
("L'albero non è vuoto, impossibile inserire la radice");
size=1;
root=createNode(o, null, null, null);
return root;
}

Qualcuno saprebbe aiutarmi gentilmente? grazie anticipatamente