# Binäer Suchbaum Probleme



## Papuerus (3. Jun 2011)

Hallo, die Aufgabe ist es an Hand des Interface <> einen <> zu Implementieren und wir dürfen die Vorgaben nicht verändern:

Das Interface:

```
package tree;

/**
 * Describes a simple interface for interferring with a tree-like structure.
 *
 * @param <T> The type the tree is to store in its nodes.
 */
public interface Tree<T extends Comparable<T>>  {

    /**
     * Inserts a value into the tree. Doubled values are overwritten.
     * A value doubles some other value if the following condition is true:
     * <code>o1.compareTo(o2) == 0</code>
     * Null values are not added into the tree.
     *
     * @param e The value to be inserted into the tree.
     */
    public void insert(T e);

    /**
     * Searches the tree for a value <code>e</code> and returns the node containing it, 
     * if it is found.
     *
     * @param e The value to be searched for.
     * @return The value e, if it exists, or <code>null</code> if the value
     * was not found
     */
    public T find(T e);

    /**
     * Removes the value <code>e</code> from the tree.
     *
     * @param e The value to be removed.
     */
    public T delete(T e);

    /**
     * Returns the list containing all elements of the tree
     * sorted using a pre-order traversing.
     *
     * <emph>Implicates the subnodes are ordered</emph>
     *
     * @return The list in the pre-order visit order.
     */
    public Object[] traversePreOrder();

    /**
     * Returns the list containing all elements of the tree
     * sorted by an in-order traversing
     *
     * <emph>Implicates a binary tree</emph>
     *
     * @return The list in the in-order visit order.
     */
    public Object[] traverseInOrder();

    /**
     * Returns the list containing all elements from the tree
     * sorted by a post-order traversing.
	 *
     * <emph>Implicates the subnodes are ordered</emph>
     *
     * @return The list in the post-order visit order.
     */
    public Object[] traversePostOrder();
}
```

Hier die einzelne Knotenklasse:

```
package tree;

import java.util.LinkedList;


class BinarySearchTreeNode<T extends Comparable<T>> implements Comparable<BinarySearchTreeNode<T>> {

    private BinarySearchTreeNode<T> left;
    private BinarySearchTreeNode<T> right;
    private T value;

    BinarySearchTreeNode(T value, BinarySearchTreeNode<T> left, BinarySearchTreeNode<T> right) {
        this.value = value;
        this.left = left;
        this.right = right;
    }

    BinarySearchTreeNode(T value) {
        this(value, null, null);
    }

    BinarySearchTreeNode<T> getLeft() {
        return left;
    }

    void setLeft(BinarySearchTreeNode<T> left) {
        this.left = left;
    }

    BinarySearchTreeNode<T> getRight() {
        return right;
    }

    void setRight(BinarySearchTreeNode<T> right) {
        this.right = right;
    }

    T getValue() {
        return value;
    }

    void setValue(T value) {
        this.value = value;
    }

    @Override
    public int compareTo(BinarySearchTreeNode<T> o) {
        return value.compareTo(o.getValue());
    }
}
```

Und hier die Binäre Baum Klasse:

```
package tree;

import java.util.LinkedList;

/**
 * Represents a binary search tree.
 * 
 * @param <T>
 *            The type of the object that are to be stored in the tree.
 */
public class BinarySearchTree<T extends Comparable<T>> implements Tree<T> {

	private BinarySearchTreeNode<T> root;
	private int elements;

	/**
	 * Constructs an empty tree.
	 */
	public BinarySearchTree() {
		elements = 0;
		root = null;
	}

	@Override
	public void insert(T e) {
		//TODO: your implementation here
		// Wenn das Element null ist
		if (e == null)
			return;
		
		//Wenn der Baum leer(null) ist
		if (this.root == null){
			this.root.setValue(e);
			this.root.setLeft(null);
			this.root.setRight(null);
		}
		//wenn das Element gleich der Wurzel ist
		if ( e.compareTo( root.getValue() )==0 )
			return;
		
		//Wenn das Element kleiner der Wurzel ist
		if ( e.compareTo( root.getValue() )== -1 ){
			insertHelp(root.getLeft(),e);
		}		
	}
	
	public void insertHelp (BinarySearchTreeNode<T> binNode, T e){
		if (root == null)
			root = new BinarySearchTreeNode(e);
		else
			root.insertHelp(root.getLeft(),e);
	}


	@Override
	public T find(T e) {
		//TODO: your implementation here
		return null;
	}


	@Override
	public T delete(T e) {
		//TODO: your implementation here
		return null;
	}

	

	@Override
	public Object[] traversePreOrder() {
		//TODO: your implementation here
		return null;
	}

	

	@Override
	public Object[] traverseInOrder() {
		//TODO: your implementation here
		return null;
	}

	@Override
	public Object[] traversePostOrder() {
		//TODO: your implementation here
		return null;
	}

	/**
	 * Constructs a tree containing the values from the list, by constructing a
	 * empty tree and successively adding the specified elements.
	 * 
	 * @param <T>
	 *            The type argument specifing the type of the items to be stored
	 *            in the tree.
	 * @param vals
	 *            The values to be inserted into the tree.
	 * @return Returns a tree containing the specified elements.
	 */
	public static <T extends Comparable<T>> BinarySearchTree<T> createTree(
			T[] vals) {
		BinarySearchTree<T> tree = new BinarySearchTree<T>();
		for (T val : vals) {
			tree.insert(val);
		}
		return tree;
	}

	/**
	 * A setter for the root-element.
	 */
	void setRoot(BinarySearchTreeNode<T> root) {
		this.root = root;
	}

	/**
	 * A getter for the root-element.
	 * 
	 * @return The root node.
	 */
	BinarySearchTreeNode<T> getRoot() {
		return root;
	}

	/**
	 * A getter for the elements-field.
	 * 
	 * @return The count of elements currently in the tree.
	 */
	public int getNumOfElements() {
		return elements;
	}
}
```

Ich bin jetzt beim einfügen und will das eigentlich rekursiv machen, aber dazu braucht man ja eigentlich irgendwie noch den Baum, deswegen dachte ich an eine HIlfsmethode, aber ich kann nicht auf insert rekursiv zugreifen, einfach weil ich in der Strucktur nicht so ganz druchblicke

könnte mir da jemand behilflich sein, vllt. erklären was ich falsch mache

lg


----------



## SlaterB (3. Jun 2011)

du bist die ganze Zeit im BinarySearchTree, insert ist eine eigene Methode, die kannst du nur ganz normal aufrufen,
insertHelp genauso, nicht an root sondern direkt so wie du von insert aus ganz normal insertHelp() aufrufst,

bisher ist aber noch nicht wirklich ersichtlich was insertHelp leisten soll, wahrscheinlich unnötig


----------



## Papuerus (3. Jun 2011)

Danke für den Hinweis 

Ich müsste doch jetzt wenn das erste Element(also root?) größer ist in den linken Teilbaum

wenn ich sage das ich in den linken Teilbaum alle kleineren einsortieren möchte

das geht aber mit der insert methode nicht, da ich da ja nur ein value Objekt so gesehen übergeben kann, was ich gerade in den Baum einsortieren muss

Deswegen dachte ich mir, ich brauche eine HIlfsmethode, welche dann einen Baum oder den Baumknoten?
und das einzufügende Element bekommt, so das ich es dann rekursiv lösen kann

lg


----------



## SlaterB (3. Jun 2011)

insert selber kannst du auch rekursiv aufrufen, wenn du das aber lieber nur mit einer anderen Methode machen willst, etwa weil du noch mehr Parameter, Informationen über die vorherige Ebene übergeben willst, dann bitte,

nur zum Vergleich von Objekten oder Werten kann eine Methode an sich aber kaum etwas beitragen, da hilft Code wie ein if


----------



## Papuerus (3. Jun 2011)

Puh das verstehe ich nicht ganz...
ich hatte gehofft es so lösen zu können:


```
@Override
	public void insert(T e) {
		//TODO: your implementation here
		
		// Wenn das Element null ist
		if (e == null)
			return;
		
		//Wenn der Baum leer(null) ist
		if (this.root == null){
			this.root = new BinarySearchTreeNode<T>(e);
			this.elements ++;
		}
		//wenn das Element gleich der Wurzel ist
		if ( e.compareTo( root.getValue() )==0 )
			return;
		
		//Wenn das Element kleiner der Wurzel ist
		if ( e.compareTo( root.getValue() )== -1 ){
			insertHelp(root.getLeft(),e);
		}
		
		//Wenn das Element kleiner der Wurzel ist
		if ( e.compareTo( root.getValue() )== 1 ){
			insertHelp(root.getRight(),e);
		}	
	}
	
	public void insertHelp (BinarySearchTreeNode<T> binNode, T e){
		if (root == null)
		{
			root = new BinarySearchTreeNode<T>(e);
			this.elements ++;
		}
		else
		{
			if (binNode.getValue().compareTo(e) == 0)
				return;
			if (e.compareTo(binNode.getValue()) == -1 )
				insertHelp(binNode.getLeft(),e);
			if ( e.compareTo(binNode.getValue()) == 1 )
				insertHelp(binNode.getRight(),e);
		}
	}
```

Aber das scheint fehlerhaft zu sein, da die JUnit Tests die wir mitbekommen haben beim Insert false zurück geben

Wie löse ich es denn in Insert mit den, gehe in den linken Baum, gehe in den rechten


----------



## Papuerus (3. Jun 2011)

Ah ok, das hier scheint jetzt zu funktionieren:


```
@Override
	public void insert(T e) {
		//TODO: your implementation here
		
		// Wenn das Element null ist
		if (e == null)
			return;
		
		//Wenn der Baum leer(null) ist
		if (this.root == null){
			this.root = new BinarySearchTreeNode<T>(e);
			this.elements ++;
		}
		//wenn das Element gleich der Wurzel ist
		if ( e.compareTo( root.getValue() )==0 )
			return;
		
		//Wenn das Element kleiner der Wurzel ist
		if ( e.compareTo( root.getValue() )== -1 ){
			insertHelp(root.getLeft(),e);
		}
		
		//Wenn das Element größer der Wurzel ist
		if ( e.compareTo( root.getValue() )== 1 ){
			insertHelp(root.getRight(),e);
		}	
	}
	
	public void insertHelp (BinarySearchTreeNode<T> binNode, T e){
		if (e == null)
			return;
		if (binNode == null)
		{
			binNode = new BinarySearchTreeNode<T>(e);
			this.elements ++;
		}
		else
		{
			if (binNode.getValue().compareTo(e) == 0)
				return;
			if (e.compareTo(binNode.getValue()) == -1 )
				insertHelp(binNode.getLeft(),e);
			if ( e.compareTo(binNode.getValue()) == 1 )
				insertHelp(binNode.getRight(),e);
		}
	}
```

ich musste in der Help mehode natürlch root in binNode ändern, da ich ja nicht mehr die obere Wurzel behandeln möchte

der JUnit Test sieht so aus:


```
@Before
    public void init() {
        intTree = new BinarySearchTree<Integer>();
        bodyTree = new BinarySearchTree<Body>();
    }

	@Test
    public void testInsert() {
		
        for (int i = 0; i < trees.length; i++) {
            BinarySearchTree<Integer> tree = new BinarySearchTree<Integer>();
			for(int j=0; j < trees[i].length; j++) {
				tree.insert(trees[i][j]);
				assertEquals("Insert failed. Element count differs in data set #" +i,
					j+1, tree.getNumOfElements());
			}
		}
    }
```


----------



## SlaterB (3. Jun 2011)

JUnit-Test ist keine Ausrede, du hast doch selber einen Kopf, kannst eine main-Methode erstellen, ein Baum-Objekt,
dort insert für ein bis mehrere Elemente aufrufen und mit Debugger oder System.out.println() nachschauen, was exakt passiert

zwei offensichtliche Hinweise:
- in insert() wird root schon gesetzt wenn nötig, in insertHelp() musst du also mit root gar nichts machen
- bisher leitet deine Rekursion nur weiter oder hört auf, außer root wird nie irgendwas gesetzt, nie setLeft() oder serRight() aufgerufen?!


----------



## Papuerus (3. Jun 2011)

Das mit root habe ich im vorherigen Post geändert(sie vor deinem^^)

aber jetzt hatte ich auch noch eine andere Idee wie man es nur in Insert lösen könnte, ich speicher mir den verweis root irgendwo rein (neuer BinaryTreeNode)
und sage dann immer in der if Bedin

```
root = root.getLeft()
```
und arbeite damit weiter

meinst du es so?

Und ich muss am Ende natürlich, nachdem ich das Element eingefügt habe, die ursprüngliche root wieder angeben

lg


----------



## SlaterB (3. Jun 2011)

auf keinen Fall root verändern, wenn du den alten Wert 'irgendwo zwischenspeicherst',
dann kopiere doch root irgendwohin und ändere diese temporäre Variable, soweit nötig,

viel meinen will ich dazu noch gar nicht,
aber ein weiterer Hinweis:
den Vergleich mit den Wert (größer, kleiner, gleich) hast du doppelt implementiert, klassisches Zeichen für nicht optimales Vorgehen,
aber besser noch als gar keine Idee

und bedenke allgemein, dass ein Vergleich nicht genau m-1, 0 +1 zurückgeben muss, unterscheide nach < 0, 0, > 0


----------



## Papuerus (3. Jun 2011)

Mit der Dopplung hast du mal wieder recht, habe es angepasst:


```
@Override
	public void insert(T e) {
		//TODO: your implementation here
		insertHelp(root,e);
	}
	
	public void insertHelp (BinarySearchTreeNode<T> binNode, T e){
		if (e == null)
			return;
		if (binNode == null)
		{
			binNode = new BinarySearchTreeNode<T>(e);
			this.elements ++;
		}
		else
		{
			if (binNode.getValue().compareTo(e) == 0)
				return;
			if (e.compareTo(binNode.getValue()) == -1 )
				insertHelp(binNode.getLeft(),e);
			if ( e.compareTo(binNode.getValue()) == 1 )
				insertHelp(binNode.getRight(),e);
		}
	}
```

Meinst du das diese Lösung falsch bzw. auch nicht optimal ist?

und



> und bedenke allgemein, dass ein Vergleich nicht genau m-1, 0 +1 zurückgeben muss, unterscheide nach < 0, 0, > 0



Das verstehe ich leider nicht genau, uns wurde gesagt das immer nur -1, 0 oder 1 zurückgeliefert wird

lg


----------



## SlaterB (3. Jun 2011)

jetzt hast du den Vergleich nur noch einmal, in der Hinsicht viel besser, geradezu optimal 
Rest funktioniert natürlich noch nicht unbedingt, kein setLeft() usw.

wenn dir das allgemein zu komplex ist denke an folgendes Beispiel:
leerer Tree, Einfügen von 1 -> wird root
Einfügen von 2 -> was passiert nun exakt?



----

> uns wurde gesagt das immer nur -1, 0 oder 1 zurückgeliefert wird
na dann teste mal folgendes Programm

```
public class Test {
    public static void main(String[] args)  {
       System.out.println("a".compareTo("c"));
    }
}
```
mit Integer-Objekten hast du in der Tat nur die begrenzte Unterscheidung, String würde aber bereits Ärger machen, 
und wie der Code auf komplette Abdeckung zu ändern ist dürfte doch klar sein


----------



## Papuerus (3. Jun 2011)

Bei Insert 2 müsste doch jetzt aber der dritte Fall zutreffen:


```
if ( e.compareTo(binNode.getValue()) == 1 )
                insertHelp(binNode.getRight(),e);
```

also schaut er im rechten baum weiter

....1....
null null

jetzt sieht er das rechts null ist und fügt das Element da neu ein mit 
	
	
	
	





```
new BinarySearchTreeNode(e);
```

......1.......
null.....2....
.....null null

ich versteh gar nicht wozu ich setLeft und setRight brauche, das sind doch Methoden von BinaryTreeNode


Ok das Beispiel mit dem Vergleich verstehe ich, aber ich glaube das können wir vernachlässigen, da uns nichts anderes gesagt wurde, wenn nicht gibt es Grundlegend andere Werte als 0, -1, 1
Also jetzt nicht immer spezifische Werte für int, double, Strings und Chars?
Weil das verstehe ich nicht
in der Javo doku steht bei Comparable das gleiche was ich meinte


> Returns:
> a negative integer, zero, or a positive integer as this object is less than, equal to, or greater than the specified object.



Und davon erben wir ja


----------



## SlaterB (3. Jun 2011)

da steht nicht dass genau -1 zurückgegeben wird, sondern 'a negative integer',
würdes du <0, 0, >0 implementieren wäre genau DAS der allgemeine Fall, damit würde dein Tree ganz simpel für alle (korrekten) Klassen der Welt funktionieren
das was du bisher hast, -1, 0, 1, ist genau einer der 'spezifischen' Fälle, weswegen dein Tree nicht mit allen Klassen der Welt funktioniert

------

new BinarySearchTreeNode(e);  ist richtig, aber mit dem Restbaum nicht verknüpft..,
aus welchem Grund sollte die 2 unter der 1 stehen und nicht woanders?
der Parameter 'binNode' ist nur eine lokale Variable, und nicht magisch verknüpf getLeft() vom letzten Aufruf..

soviel einzeln zu beantworten.., jetzt antworte ich als Selbstauflage ganze zwei Stunden nicht mehr 
überlege dir genau was du selber testen oder durch Denken herausfinden kannst 
und poste nicht bei jedem Problem einfach im Forum um es andere lösen zu lassen


----------



## Papuerus (3. Jun 2011)

Entschuldigung wenn es so rüber kommt, aber es sind eher Fragen zu Java allgemein die mir Probleme bereiten, eben mit Datenstruckturen usw.

Und solche Feinheiten übersehe ich auch gerne, aber ich will wirklich  nicht andere Leute meine Probleme Lösen lassen

Und das ich einfach eine Abfrage, ob der Wert < 0, ob wert > 0, das hatte ich falsch verstanden, weil ich mich die ganze Zeit gefragt habe mit was <> und da drinnen eben 0,0 gemeint ist und nicht e > 0, e = 0, e < 0 z.B.....

Jetzt habe ich verstanden was du gemeint hast, sry, ein simples Verständnisproblem, ja liegt an mir...
Habe es natürlich in größer 0 kleiner 0 geändert

PS:
Müsste ích die Hausaufgabe nicht bis 16 Uhr abgeben, würde ich sicher nicht soviel Fragen, ist irgendwie keine Entschuldigung aber tut mir dennoch leid


----------



## Papuerus (3. Jun 2011)

Der Debugger zeigt mir ganz klar, das er, wenn er die 2 einfügen will, wieder einen leeren baum nutzen will, aber ich dachte das müsste mit den Referenzen so gehen, ich wüsste jetzt nicht wie man es anders machen kann, also die beiden verknüpfen

lg


----------



## SlaterB (4. Jun 2011)

die 2 soll bei root der rechte Nachfolger sein, seit Ewigkeiten bemeckere ich dass du nie setLeft(), setRight() benutzt,
aber weiter nicht den Hauch einer Idee?


----------



## Papuerus (5. Jun 2011)

Mir ist schon klar das man eine Verbindung zur Root herstellen muss, ich dachte auch das ich das tue wenn ich den neuen BinaryTreeNode erstelle

Aber ich versteh auch nicht: ist es grundlegend eigentlich nötig das man eine Klasse BinaryTreeNode benutzt? (Zwischenfrage)

Könnte man einen BinarySearchTree nicht auch einfach selbst so definieren, das der als linken und rechten nachfolger einen BinarySearchTree hat, und da eine Insert Funktion einarbeiten?

da fände ich es nämlich kein Problem

ich verstehe einfach nicht wie ich das so ohne weiteres mit root verbinden soll

Ja setLeft und setRight schon klar, aber wenn ich das übergebe ist das doch auch wieder ein anderer oder nicht, also es scheitert ja schon bei der Übergabe an InsertHelp

Wieso ist die Referenz da nicht mehr mit Root verbinden, also ich dachte der erste binNode ist immer noch root, auch wenn sie dann in InsertHelp binNode heißt, eben weil es doch nur eine Referenz ist und alles was ich an binNode verändere müsste sich doch dann auch an root verändern?

lg


----------



## SlaterB (5. Jun 2011)

> Könnte man einen BinarySearchTree nicht auch einfach selbst so definieren, das der als linken und rechten nachfolger einen BinarySearchTree hat, und da eine Insert Funktion einarbeiten?

gut denkbar

> aber wenn ich das übergebe ist das doch auch wieder ein anderer oder nicht

das ist so allgemein, da kann man alles mögliche drauf antworten, nimm doch das ganz konkrete Beispiel mit der 2 nach der 1, 
welche Methode kommt wann mit welchen Parametern dran, was geht noch, was geht schon?
ein gewisses Problem besteht gewiss, das musst du aber lösen

der letzte Satz ist als Fortführung eine denkwürdige Ansammlungen von Ungenauigkeiten,
und mach keine Annahmen über Variablen, Sonne Mond und Sterne sondern programmiere alles messerschaft wie es werden soll


----------



## Papuerus (5. Jun 2011)

Ja Java macht mir das nicht leicht 

Also, wenn ich root an insertHelp übergebe, dann übergebe ich doch nur eine Referenz von root oder?
Wie sieht es denn aus, wenn root null ist, dann existiert Root ja eigentlich nicht oder, also als Objekt, ist das der Fall den ich berücksichtigen muss?
Java wirkt auf mich einfach manchmal so undurchsichtig was den Hintergrund allgemein angeht

vllt. liegt es auch daran, das ich aus der funktionalen Programmierung komme, kA

lg


----------



## SlaterB (5. Jun 2011)

> Also, wenn ich root an insertHelp übergebe, dann übergebe ich doch nur eine Referenz von root oder?
ja, eine Referenz

schade dass du das 'oder' nicht beschreibst so dass weiter nicht klar ist worum es dir geht

root == null solltest du mit dem Code abdecken den du schon hattest, der aktuell aber wohl fehlt

```
if (this.root == null){
            this.root = new BinarySearchTreeNode<T>(e);
            this.elements ++;
        }
```
schreibe das irgendwo und fertig, über root == null nachdenken ab sofort verboten


----------



## Papuerus (6. Jun 2011)

Ok das müsste soweit die Lösung sein, beim Debuggen hab ich da zumindest keinen Fehler mehr gefunden (nur in meiner toString Methode xD)


```
@Override
	public void insert(T e)
	{
		//TODO: your implementation here
		if (this.root == null)
		{
			this.root = new BinarySearchTreeNode<T>(e);
			this.elements ++;
			return;
		}
		else
		{
			insertHelp(root,e);
		}
	}
	
	private void insertHelp (BinarySearchTreeNode<T> binNode, T e)
	{
		BinarySearchTreeNode<T> newelement = new BinarySearchTreeNode<T>(e);
		if (e == null | e.compareTo( binNode.getValue())== 0)
			return;
		
		if ( e.compareTo(binNode.getValue() ) > 0 )
		{
			if ( binNode.getRight() == null )
			{
				binNode.setRight(newelement);
				this.elements ++;
			}
			else
				insertHelp(binNode.getRight(),e);
		}
		
		if ( e.compareTo(binNode.getValue() ) < 0 )
		{
			if ( binNode.getLeft() == null )
			{
				binNode.setLeft(newelement);
				this.elements ++;
			}
			else
				insertHelp(binNode.getLeft(),e);
		}
	}
```

fragt sich nur ob das so optimal im Sinne von Sauber ist, z.B. die erste Abfrage bezüglich e in insertHelp könnte man ja auch in insert packen, ob das dann sauberer ist?


----------



## SlaterB (6. Jun 2011)

unbedingt, meiner Ansicht nach, 
allgemein || statt | verwenden,

newelement = new BinarySearchTreeNode<T>(e);
zu Beginn der insertHelp-Methode spart eine doppelte Zeile, aber dass dafür unbenutze Fachobjekte erzeugt werden ist eigentlich nicht zu rechtfertigen, 
schreibe das dort wo es nötig ist, bei den elements++ Zeilen

e.compareTo( binNode.getValue()) könntest du in einer Variablen int c speichern statt dreimal zu schreiben,
aber das sind nun Kleinigkeiten, schon recht gut geworden


----------



## Papuerus (6. Jun 2011)

Danke , genau solche Tipps meinte ich aber 

braucht man das einfache | (oder) überhaupt jemals?

ich habe auch noch bei den 
	
	
	
	





```
elements++;
```


```
return;
```
hinzugefügt, da es ja nicht nötig ist danach noch den recht weiter durchzugehen


```
@Override
	public void insert(T e)
	{
		//TODO: your implementation here
		if (this.root == null)
		{
			this.root = new BinarySearchTreeNode<T>(e);
			this.elements ++;
			return;
		}
		else
		{
			insertHelp(root,e);
		}
	}
	
	private void insertHelp (BinarySearchTreeNode<T> binNode, T e)
	{
		int elementcomparablevalue = e.compareTo(binNode.getValue() ) ;
		
		if (e == null || elementcomparablevalue == 0)
			return;		
		
		if ( elementcomparablevalue  > 0 )
		{
			if ( binNode.getRight() == null )
			{
				BinarySearchTreeNode<T> newelement = new BinarySearchTreeNode<T>(e);
				binNode.setRight(newelement);
				this.elements ++;
				return;
			}
			else
				insertHelp(binNode.getRight(),e);
		}
		
		if ( elementcomparablevalue < 0 )
		{
			if ( binNode.getLeft() == null )
			{
				BinarySearchTreeNode<T> newelement = new BinarySearchTreeNode<T>(e);
				binNode.setLeft(newelement);
				this.elements ++;
				return;
			}
			else
				insertHelp(binNode.getLeft(),e);
		}
	}
```


----------



## SlaterB (6. Jun 2011)

ich selber kann mich an keine Verwendung von | erinnern


----------



## Papuerus (6. Jun 2011)

es gibt doch noch ein (Gedanken?!) Problem bzw. Verständnisproblem:

Was passiert wenn bei folgendem Code e == null ist?

```
int elementcomparablevalue = e.compareTo(binNode.getValue() ) ;
        
        if (e == null || elementcomparablevalue == 0)
            return;
```

Denn, wenn ich die Abfragen aufsplitte:

```
int elementcomparablevalue = e.compareTo(binNode.getValue() ) ;
        
        if (e == null) 
            return; 
        if (elementcomparablevalue == 0)
          return;
```
Dann wird mir gesagt das 
	
	
	
	





```
if (e == null)
```
toter Code ist
Also wäre meine Frage ob ich es so umschreiben muss:


```
if (e == null)
			return;
		
		int elementcomparevalue = e.compareTo(binNode.getValue() ) ;
		
		if (elementcomparevalue == 0)
			return;
```

oder ob 

```
int elementcomparevalue = e.compareTo(binNode.getValue() ) ;
```
automatisch return macht wenn e == null ist, denn einfügen will ich es ja eigentlich nicht!

lg


----------



## SlaterB (6. Jun 2011)

du musst es umschreiben, ja, sonst droht NullPointerException,

wie du um 16:42 schreibst reicht es ja auch, e==null nur einmal in insert zu testen, nicht bei der Rekursion ständig neu


----------



## Papuerus (6. Jun 2011)

Ja habe es angepasst^^

meine find methode schaut nun so aus, da müsste es ja standard mäßig gehen:

```
@Override
	public T find(T e) {
		//TODO: your implementation here
		if ( e == null)
			return null;
		return findHelp(root, e);
	}
	
	private T findHelp(BinarySearchTreeNode<T> binNode, T e){

		if (binNode == null)
			return null;
		else
		{
			int elementcomparevalue = e.compareTo(binNode.getValue());
			
			if (elementcomparevalue == 0)
				return binNode.getValue();
			if (elementcomparevalue < 0)
				return findHelp(binNode.getLeft(),e);
			if (elementcomparevalue > 0)
				return findHelp(binNode.getRight(),e);
		}
		return null;
	}
```


----------

