Szybszy sposób tworzenia struktury drzewa

Witam,

Mam następujący problem z drzewem w Javie:

Dwa polecenia już z grubsza wykonałem, lecz jestem zainteresowany zadaniem dodatkowym którego nie umiem zrobić:

Wykonano:

1. Uzupełnij klasę Node<T> oraz Tree<T> o brakujące metody. W klasie Tree<T> dodaj metody
   umożliwiające poruszanie się po drzewie i wyświetlanie jego zawartości (wykorzystaj widok drzewa
   z wcięciami)
2. Przetestuj napisane przez siebie klasy poprzez utworzenie drzewa występującego w części “Reprezentacja
   struktury drzewa” oraz zastosowanie podstawowych metod.

Z czym mam problem:
3. Zastanów się nad innym sposobem tworzenia struktury drzewa węwnątrz kodu programu (chcemy
ominąć mozolne tworzenie poszczególnych węzłów i ręczne ustalanie relacji pomiędzy nimi).

Mój kod:

import java.lang.*;
import java.util.*;

interface INode<T> {
public Node<T> getParent(); // zwraca referencje rodzica
public void setParent(Node<T> parent); // ustawia rodzica dla węzła
public T getData(); // zwraca przechowywane dane
public void setData(T data); // ustawia dane w węźle
public int getDegree(); // zwraca stopień węzła
public Node<T> getChild(int i); // zwraca referencje do i-tego dziecka
public boolean isLeaf(); // sprawdza czy węzeł jest liściem
public Node<T> addChild(Node<T> child); // dodaje do węzła dziecko (inny węzeł)
public Node<T> addChild(T data); // tworzy i dodaje do węzła dziecko z danymi
public Node<T> removeChild(int i); // usuwa i-te dziecko węzła
public void removeChildren(); // usuwa wszystkie dzieci węzła
public Node<T> getLeftMostChild(); // zwraca pierwsze dziecko węzła (z lewej)
public LinkedList<Node<T>> getChildren(); // zwraca listę dzieci
public Node<T> getRightSibling(); // zwraca kolejny element siostrzany węzła
public String toString(); // wyświetla węzeł (najczęściej dane)
}


class Node<T> implements INode<T> {
private T data; // dane
private Node<T> parent; // referencja do rodzica
private LinkedList<Node<T>> children; // lista dzieci
public Node() { // konstruktor domyślny
parent = null;
children = new LinkedList<Node<T>>();
}
public Node(Node<T> parent) { // konstruktor jednoparametrowy
this();
this.parent = parent;
}
public Node(Node<T> parent, T data) { // konstruktor dwuparametrowy
this(parent);
this.data = data;
}
  // pozostałe metody zgodnie z interfejsem INode<T>
public Node<T> getParent(){
  return parent;
}

public void setParent(Node<T> parent){
  this.parent=parent;
}
public T getData(){ // zwraca dane
  return data;
}
public void setData(T data){ //przyporzadkowuje dane
  this.data=data;
}
public int getDegree(){ //zwraca stopien
  return children.size();
}
public Node<T> getChild(int i){
  return children.get(i);
}
public boolean isLeaf(){
  return children.isEmpty();
}
public Node<T> addChild(Node<T> child){
  children.add(child);
  return child; // zwraca refenncje do child


}

  //druga wersja

public Node<T> addChild(T data){

  Node<T> a= new Node<T>(this, data); // this dlatego, ze jestesmy tutaj parent, data to nasza etykieta
  children.add(a); //a to referencja do node'a
  return a; // zwraca a
}
public Node<T> removeChild(int i){
  return children.remove(i);
}
public void removeChildren(){
  children.clear();
}
public Node<T> getLeftMostChild(){
  return children.getFirst();
}
public LinkedList<Node<T>> getChildren(){
  return children;
}

public Node<T> getRightSibling() {
  int i = this.getParent().children.indexOf(this);
  return this.getParent().children.get(i+1);
  }
public String toString()
  { return ;
}
}

Chodzi zapewne o kopce ;)
http://pl.wikipedia.org/wiki/Kopiec_binarny

Tyle tylko, że kopiowanie tablic przy poszerzaniu drzewa będzie bardzo powolne.

Dzięki,

A co z brakującą metodą toString? Jak ją skonstruuować?
W kodzie nie mam nic po return, więc program oczywiście się nie kompiluje.
Jak to uzupełnić by metoda działała?

a wypisz rekurencyjnie...

public String toString()
  { 
StringBuilder b = new StringBuilder();

for(int i =0; i< getDegree(); i++){
b.append(" "); // tu są spacje odpowiedzilane za wcięcia
}
b.append(getData().toString());  // dana z danego węzła... pomyśl o nazywaniu węzłów.
b.append("\n"); // wchodzimy poziom niżej
for(Node<T> n: children ){
b.append(n.toString());
}

return b.toString();
}