Generischer Binärbaum (compareTo Frage)

[puelo]

Hallo,

ich habe folgende Aufgabenstellung:

Verallgemeinern Sie Ihre Implementierung des Binarbaums IntBinaryTree, indem Sie eine neue
generische Klasse GenericBinaryTree programmieren, die beliebige Referenztypen T als Knotenwerte
zulasst.
Um beliebige Referenzen T in einen Binarbaum einfugen zu konnen, muss es eine Ordnung auf
Instanzen dieses Typs geben, d.h. beliebige Instanzen von T müssen miteinander vergleichbar sein.
Stellen Sie also sicher, dass nur solche T erlaubt sind, die das Interface Comparable<T> implementieren
und benutzen Sie beim Einfugen in Ihren generischen Baum die entsprechende Vergleichsmethode
dieses Interfaces, um zu entscheiden, ob Sie in den linken oder rechten Teilbaum einfugen
mussen.

Ich habe jetzt folgendes programmiert:

public class GenericBinaryTree<T> implements Comparable<T>{
    public T value;
    public GenericBinaryTree<T> rightNode;
    public GenericBinaryTree<T> leftNode;
    
    public GenericBinaryTree (T value){
        this.value = value;
    }

    @Override
    public int compareTo(T o){
        return this.compareTo(o);
    }
    public void insert (T newValue){
        if(newValue instanceof Comparable){
            if(compareTo(newValue) < 0){
                if(rightNode != null){
                    rightNode.insert(newValue);
                }else{
                    rightNode = new GenericBinaryTree<T>(newValue);
                }
            }else{
            if(leftNode != null){
                leftNode.insert(newValue);
            }else{
                leftNode = new GenericBinaryTree<T>(newValue);
            }
            }
        }else{
            System.out.println("newValue does not implement Comparable");
        }
        
    }

    @Override
    public String toString(){
        String bTreeString = "";
        if(leftNode != null){
            bTreeString += leftNode.toString();
        }
            bTreeString += this.value+", ";
        if(rightNode != null){
            bTreeString += rightNode.toString();
        }
            return bTreeString;

    }
}

Nun wollte ich wissen, ob es 1. eine andere / bessere Möglichkeit gibt, wie in der Angabe gefordert, sicher zu stellen, dass T das Interface Comparable implementiert und 2. die implementierung von compareTo so in Ordnung ist.
Danke für jede Info!

 

[dayaftereh]

Hey, du kannst folgendes tuhen:

public class Test<T extends Comparable<T>> {
	public int test(T e, T e2){
		return e.compareTo(e2);
	}
}

Jetzt hast du sichergestellt das T Comparable sein muss.

 

[Michael...]

1. Ich habe nirgends gelesen, dass die Tree Klasse Comparable implementieren soll, es soll nur sichergestellt werden, das T Comparable implementiert.
2. würde ein Aufruf Deiner (nicht notwendigen) compareTo Methode zu einer Endlosschleife und somit zu einem StackOverflow führen.

 

[turtle]

public class GenericBinaryTree<T extends Comparable<T>>

 

[puelo]

Danke für die Tipps erstmal.
Hier der überarbeitete Code:

public class GenericBinaryTree <T extends Comparable<T>> {
    public T value;
    public GenericBinaryTree<T> rightNode;
    public GenericBinaryTree<T> leftNode;
    
    public GenericBinaryTree (T value){
        this.value = value;
    }

    public int compareThem(T o, T o2){
        return o2.compareTo(o);
    }
    public void insert (T newValue){
            if(compareThem(newValue, this.value) < 0){
                
                if(rightNode != null){
                    rightNode.insert(newValue);
                }else{
                    rightNode = new GenericBinaryTree<T>(newValue);
                }
            }else{
            if(leftNode != null){
                leftNode.insert(newValue);
            }else{
                leftNode = new GenericBinaryTree<T>(newValue);
            }
            
        }
        
    }