BlueJ: Suchbaum: Projekt "Visitenkarten"

[Ne0Nebul0sa]

Hallo liebes Forum,

Ich sitze gerade an einem Projekt "Visitenkarten", welches in Java programmiert werden soll. Ich benutze die SuM-Bibliothek und programmiere (zwangsweise) mit BlueJ.

Das Projekt beschäftigt sich mit dem Erarbeiten eines Suchbaums (ähnlich dem Binärbaum).

Der bisherige Projektfortschritt:

Klasse Suchbaum:

import bspg.strukturen.*;

public class Suchbaum extends Baum

{

    // Bezugsobjekte

    Visitenkarte lVKarte;


    // Attribute


    // Konstruktor

    public Suchbaum(Ordnungsobjekt pInhalt)

    {

        super(pInhalt);

    }


    // Dienste

    public void fuegeEin(Ordnungsobjekt pInhalt)

    {

       String lName, lTelefon, lEmail;

       if(!this.istLeer())

       {

            lVKarte = new Visitenkarte(lName, lTelefon, lEmail);

            if(this.istKleinerAls(pInhalt))

            {

                return new Baum(inhalt(), fuegeEin(linkerTeilbaum(),lVKarte),rechterTeilbaum());

            }

            else if(this.istGroesserAls(pInhalt))

            {

                return new Baum(inhalt(), linkerTeilbaum(),fuegeEin(rechterTeilbaum(),lVKarte));

            }

            else

            {

                return lBaum;

            }

       }

       else

       {

           return new Baum(pInhalt);

       }

    }


    public void sortiereListe()

    {

        if(!this.istLeer())

        {

            sortiereListe(linkerTeilbaum(), lListe);

            lListe.FuegeDahinterEin(inhalt());

            this.vor();

            sortiereListe(rechterTeilbaum(), lListe);

        }

    }


    public Ordnungsobjekt suche(Ordnungsobjekt pInhalt)

    {

       //erg�nze

       Liste lListe = new Liste();

       sortiereListe(lBaum, lListe);

       return lListe;

    }

Der Code ist ansich recht verständlich und gut übersichtlich. Die Methoden "sortiereListe","suche" und "fuegeEin" sind selbst programmiert und ich weiß deshalb nicht, ob sie korrekt sind. Ich bekomme zur Zeit immer den Fehler "cannot find symbol - Method IstKleinerAls(bspg.strukturen.Ordnungsobjekt)". Der Fehler sagt offentsichtlich aus, dass die Methode nicht gefunden wurde. Allerdings bin ich zu blauäugig die Problemlösung zu sehen. Da ich mir aber überhaupt nicht sicher bin, ob mein Gedankengang im Programm selbst und die Syntax korrekt ist, stelle ich lieber gleich die Frage "der Elite" ;-) (edit): Mir fehlt auch noch die Abfrage, wenn die Teilbäume leer sind. Diese müssen dann logischerweise erzeugt werden. - Dazu in der If-Abfrage (in den Methoden IstKleinerAls,etc.) eine neue If-Afrage mit sowas wie "!linkerTeilBaum.istLeer()" und wenn false (für den else-Zweig) "new Baum(null, liTB, null);" ? Ferner danke ich euch jetzt schon einmal für alle Hilfen, Antworten und Ideen und wünsche einen angenehmen Wochenstart. Viele Grüße Ne0Nebul0sa --Anhang: Zum Nachvollziehen einzelner Methoden auch noch die Klasse Visitenkarte (funktioniert und ursprl. vorgegeben):

import bspg.strukturen.*;

/**

 * @author Bernard Schriek

 * @version 08.08.2006

 */

public class Visitenkarte implements Ordnungsobjekt

{

    // Bezugsobjekte


    // Attribute

    private String zName;

    private String zTelefon;

    private String zEmail;


    // Konstruktor

    public Visitenkarte(String pName, String pTelefon, String pEmail)

    {

        zName = pName;

        zTelefon = pTelefon;

        zEmail = pEmail;

    }


    // Dienste

    public String name()

    {

        return zName;

    }


    public String telefon()

    {

        return zTelefon;

    }


    public String email()

    {

        return zEmail;

    }


    public String toString()

    {

        return zName + " " + zTelefon + " " + zEmail;

    }


    public boolean istGroesserAls(Ordnungsobjekt pOrdnungsobjekt)

    {

        Visitenkarte lVisitenkarte;


        lVisitenkarte = (Visitenkarte)pOrdnungsobjekt;

        return this.name().compareTo(lVisitenkarte.name()) > 0;

    }


    public boolean istKleinerAls(Ordnungsobjekt pOrdnungsobjekt)

    {

        Visitenkarte lVisitenkarte;


        lVisitenkarte = (Visitenkarte)pOrdnungsobjekt;

        return this.name().compareTo(lVisitenkarte.name()) < 0;

    }


    public boolean istGleichWie(Ordnungsobjekt pOrdnungsobjekt)

    {

        Visitenkarte lVisitenkarte;


        lVisitenkarte = (Visitenkarte)pOrdnungsobjekt;

        return this.name().compareTo(lVisitenkarte.name()) == 0;

    }

}

Sowie, falls benötigt, noch die Klasse Visitenkartenanwendung:

/**

 * Die Klasse Visitenkartenanwendung wurde automatisch erstellt: 

 * 

 * @author Bernard Schriek

 * @version 11.8.2006

 */


import sum.komponenten.*;

import sum.werkzeuge.*;

import sum.ereignis.*;

import bspg.strukturen.*;


public class Visitenkartenanwendung extends EBAnwendung

{

    // Objekte

    private Etikett hatEtikettSuchbaumtest;

    private Knopf hatKnopfEinfuegen;

    private Knopf hatKnopfLoeschen;

    private Knopf hatKnopfSuchen;

    private Zeilenbereich hatZeilenbereichSuchbaum;

    private Etikett hatEtikettSuchbaum;

    private Knopf hatKnopfBeenden;

    private Etikett hatEtikettMeldung;

    private Etikett hatEtikettName;

    private Etikett hatEtikettTelefon;

    private Etikett hatEtikettEmail;

    private Textfeld hatTextfeldName;

    private Textfeld hatTextfeldTelefon;

    private Textfeld hatTextfeldEmail;

    private Knopf hatKnopfErzeugen;


    private Suchbaum hatSuchbaum;

    private Rechner hatRechner;


    // Attribute


/**

 * Konstruktor

 */

    public Visitenkartenanwendung()

    {

        //Initialisierung der Oberklasse

        super(650, 430);


        hatEtikettSuchbaumtest = new Etikett(140, 4, 100, 25, "Suchbaumtest");

        // Ausrichtung

        hatEtikettSuchbaumtest.setzeAusrichtung(Ausrichtung.LINKS);

        hatKnopfEinfuegen = new Knopf(423, 182, 100, 30, "Einf�gen");

        hatKnopfEinfuegen.setzeBearbeiterGeklickt("hatKnopfEinfuegenGeklickt");

        hatKnopfLoeschen = new Knopf(424, 222, 100, 30, "L�schen");

        hatKnopfLoeschen.setzeBearbeiterGeklickt("hatKnopfLoeschenGeklickt");

        hatKnopfSuchen = new Knopf(424, 260, 100, 30, "Suchen");

        hatKnopfSuchen.setzeBearbeiterGeklickt("hatKnopfSuchenGeklickt");

        hatZeilenbereichSuchbaum = new Zeilenbereich(14, 80, 400, 300, "");

        hatEtikettSuchbaum = new Etikett(14, 42, 100, 25, "Suchbaum");

        // Ausrichtung

        hatEtikettSuchbaum.setzeAusrichtung(Ausrichtung.LINKS);

        hatKnopfBeenden = new Knopf(425, 348, 100, 30, "Beenden");

        hatKnopfBeenden.setzeBearbeiterGeklickt("hatKnopfBeendenGeklickt");

        hatEtikettMeldung = new Etikett(15, 393, 300, 25, "Meldung");

        // Ausrichtung

        hatEtikettMeldung.setzeAusrichtung(Ausrichtung.LINKS);

        hatEtikettName = new Etikett(422, 81, 60, 25, "Name");

        // Ausrichtung

        hatEtikettName.setzeAusrichtung(Ausrichtung.RECHTS);

        hatEtikettTelefon = new Etikett(422, 115, 60, 25, "Telefon");

        // Ausrichtung

        hatEtikettTelefon.setzeAusrichtung(Ausrichtung.RECHTS);

        hatEtikettEmail = new Etikett(422, 148, 60, 25, "Email");

        // Ausrichtung

        hatEtikettEmail.setzeAusrichtung(Ausrichtung.RECHTS);

        hatTextfeldName = new Textfeld(489, 81, 150, 25, "");

        // Ausrichtung

        hatTextfeldName.setzeAusrichtung(Ausrichtung.LINKS);

        hatTextfeldTelefon = new Textfeld(489, 115, 150, 25, "");

        // Ausrichtung

        hatTextfeldTelefon.setzeAusrichtung(Ausrichtung.LINKS);

        hatTextfeldEmail = new Textfeld(490, 148, 150, 25, "");

        // Ausrichtung

        hatTextfeldEmail.setzeAusrichtung(Ausrichtung.LINKS);

        hatKnopfErzeugen = new Knopf(425, 300, 100, 30, "Erzeugen");

        hatKnopfErzeugen.setzeBearbeiterGeklickt("hatKnopfErzeugenGeklickt");


        hatSuchbaum = new Suchbaum(null);

        hatRechner = new Rechner();

    }


/**

 * Vorher: Ereignis GeklicktvonhatKnopfEinfuegen fand statt.

 * Nachher: (schreiben Sie, was in dieser Methode ausgefuehrt wird)

 */

    public void hatKnopfEinfuegenGeklickt()

    {

        Visitenkarte lVisitenkarte;

        String lName, lTelefon, lEmail;


        lName = hatTextfeldName.inhaltAlsText();

        lTelefon = hatTextfeldTelefon.inhaltAlsText();

        lEmail = hatTextfeldEmail.inhaltAlsText();

        lVisitenkarte = new Visitenkarte(lName, lTelefon, lEmail);

        hatSuchbaum.fuegeEin(lVisitenkarte);

        hatZeilenbereichSuchbaum.setzeInhalt(hatSuchbaum.toString());

        hatEtikettMeldung.setzeInhalt("Visitenkarte wurde eingef�gt");

    }


/**

 * Vorher: Ereignis GeklicktvonhatKnopfLoeschen fand statt.

 * Nachher: (schreiben Sie, was in dieser Methode ausgefuehrt wird)

 */

    public void hatKnopfLoeschenGeklickt()

    {

        Visitenkarte lVisitenkarte;

        String lName;


        lName = hatTextfeldName.inhaltAlsText();

        lVisitenkarte = new Visitenkarte(lName, "", "");

        hatSuchbaum.loesche(lVisitenkarte);

        hatZeilenbereichSuchbaum.setzeInhalt(hatSuchbaum.toString());

        hatEtikettMeldung.setzeInhalt("Visitenkarte wurde gel�scht");

    }


/**

 * Vorher: Ereignis GeklicktvonhatKnopfSuchen fand statt.

 * Nachher: (schreiben Sie, was in dieser Methode ausgefuehrt wird)

 */

    public void hatKnopfSuchenGeklickt()

    {

        Visitenkarte lVisitenkarte, lGesuchteVisitenkarte;

        String lName;


        lName = hatTextfeldName.inhaltAlsText();

        lVisitenkarte = new Visitenkarte(lName, "", "");

        lGesuchteVisitenkarte = (Visitenkarte)hatSuchbaum.suche(lVisitenkarte);

        if (lGesuchteVisitenkarte != null)

        {

            hatEtikettMeldung.setzeInhalt("Visitenkarte wurde gefunden");

            hatTextfeldTelefon.setzeInhalt(lGesuchteVisitenkarte.telefon());

            hatTextfeldEmail.setzeInhalt(lGesuchteVisitenkarte.email());

        }

        else

        {

            hatEtikettMeldung.setzeInhalt("Visitenkarte wurde nicht gefunden");

            hatTextfeldTelefon.loescheAlles();

            hatTextfeldEmail.loescheAlles();

        }

    }


/**

 * Vorher: Ereignis GeklicktvonhatKnopfBeenden fand statt.

 * Nachher: (schreiben Sie, was in dieser Methode ausgefuehrt wird)

 */

    public void hatKnopfBeendenGeklickt()

    {

        this.beenden();

    }


/**

 * Vorher: Ereignis GeklicktvonhatKnopfErzeugen fand statt.

 * Nachher: (schreiben Sie, was in dieser Methode ausgefuehrt wird)

 */

    public void hatKnopfErzeugenGeklickt()

    {

        int lZahl;

        String lName, lTelefon, lEmail;

        Visitenkarte lVisitenkarte;


        for (int i = 0; i < 1000; i++)

        {

            lZahl = hatRechner.ganzeZufallszahl(1000, 9999);

            lName = "Meier" + lZahl;

            lTelefon = "0211/" + lZahl;

            lEmail = "User" + lZahl + "@xyz.de";

            lVisitenkarte = new Visitenkarte(lName, lTelefon, lEmail);

            hatSuchbaum.fuegeEin(lVisitenkarte);

        }

        hatEtikettMeldung.setzeInhalt("1000 neue Visitenkarten erzeugt.");

        hatZeilenbereichSuchbaum.setzeInhalt(hatSuchbaum.toString());

    }


}

Die Klasse Baum wird in diesem Fall zwar ebenfalls benötigt, ist aber eigentlich nur indirekt von Relevanz - zur Sicherheit aber trotzdem:

public class Baum

{

    // Bezugsobjekte

    Object kenntInhalt;

    Baum kenntLinks;

    Baum kenntRechts;

    // Attribute


    // Konstruktor

    public Baum(Object pInhalt)

    {

        kenntInhalt = pInhalt;

        kenntLinks = null;

        kenntRechts = null;

    }


    public Baum(Object pInhalt, Baum pLinks, Baum pRechts)

    {

        kenntInhalt = pInhalt;

        kenntLinks = pLinks;

        kenntRechts = pRechts;

    }

    // Dienste


    public Object inhalt()

    {

        return kenntInhalt;

    }


    public void setzeInhalt(Object pInhalt)

    {

        kenntInhalt = pInhalt;

    }


    public Baum linkerTeilbaum()

    {

        return kenntLinks;

    }


    public boolean istLeer()

    {

        return kenntInhalt == null;

    }


    public void setzeLinkenTeilbaum(Baum pBaum)

    {

        kenntLinks = pBaum;

    }


    public Baum rechterTeilbaum()

    {

        return kenntRechts;

    }


    public void setzeRechtenTeilbaum(Baum pBaum)

    {

        kenntRechts = pBaum;

    }


    public boolean istBlatt()

    {

        return kenntInhalt != null && kenntLinks == null && kenntRechts == null;

    }

}

Bearbeitet 21. Mai 2012 von Ne0Nebul0sa
Abfang von NullPointer [s. (edit) im Post]

[habbeda]

Innerhalb Deiner Klasse "Suchbaum" befindet sich folgende Zeile:

this.istKleinerAls(pInhalt)

"this" bezieht sich auf ein Objekt der Klasse "Suchbaum". Implementiert ist die Methode jedoch in der Klasse "Visitenkarte". Der Compiler hat also vollkommen recht damit, dass die Methode so nicht existiert.

[Ne0Nebul0sa]

Natürlich. Danke für die Hilfe.

Habe ich geändert. Ebenso noch 2 andere, kleine Fehler.

Momentaner Fehler: Der Konstruktor der Klasse "Baum" kommt nicht mit der Struktur (Object, Ordnungsobjekt, Baum) klar (s. neuen Code). Ist naheliegend, da er so programmiert wurde, dass, nur folgende Konstruktoren möglich sind:

    public Baum(Object pInhalt) 

oder

    public Baum(Object pInhalt, Baum pLinks, Baum pRechts) 

Irgendwelche Lösungsansätze? Der jetzige Code sieht wie folgt aus:

    public Ordnungsobjekt fuegeEin(Baum lBaum,Ordnungsobjekt pInhalt)

    {

       //erg�nze

       String lName, lTelefon, lEmail;

       if(!this.istLeer())

       {

            lVKarte = new Visitenkarte(lName, lTelefon, lEmail);

            if(lVKarte.istKleinerAls(pOrdnungsobjekt))

            {

                return new Baum(inhalt(), fuegeEin(lBaum.linkerTeilbaum(),lVKarte),rechterTeilbaum());

            }

            else if(lVKarte.istGroesserAls(pInhalt))

            {

                return new Baum(inhalt(), linkerTeilbaum(),fuegeEin(lBaum.rechterTeilbaum(),lVKarte));

            }

            else

            {

                return lBaum;

            }

       }

       else

       {

           return new Baum(pInhalt);

       }

    }

Bin ein wenig ratlos. Danke für die Hilfe nochmals!

(edit): Ich hoffe natürlich auf einen Lösungsvorschlag, der nicht den Konstruktor des Baumes verändern möchte :-).

Bearbeitet 21. Mai 2012 von Ne0Nebul0sa
Anmerkung [s. (edit)]

[Aliter]

Habe ich geändert. Ebenso noch 2 andere, kleine Fehler.

Momentaner Fehler: Der Konstruktor der Klasse "Baum" kommt nicht mit der Struktur (Object, Ordnungsobjekt, Baum) klar (s. neuen Code). Ist naheliegend, da er so programmiert wurde, dass, nur folgende Konstruktoren möglich sind:

Was meinst du mit "Der Konstruktor der Klasse Baum kommt damit nicht klar"? Fehlermeldung?

[Ne0Nebul0sa]

Hi,

Danke für die Antwort.

cannot find symbol - constructor Baum(java.lang.Object,bspg.strukturen.Ordnungsobjekt,Baum)

Wie gesagt:

(edit): Ich hoffe natürlich auf einen Lösungsvorschlag, der nicht den Konstruktor des Baumes verändern möchte :-).

:-)

Viele Grüße

Ne0Nebul0sa

[Aliter]

In dieser Zeile

return new Baum(inhalt(), fuegeEin(lBaum.linkerTeilbaum(),lVKarte),rechterTeilbaum());

willst du einen neuen Baum erstellen, rufst dabei aber eine Methode auf ("fuegeEin"), welche ein "Ordnungsobjekt" (Kannst du davon den Code posten? Ist das ein Interface/Klasse?) zurückgibt. Der Konstruktor erwartet aber entweder

    public Baum(Object pInhalt)

    {

        kenntInhalt = pInhalt;

        kenntLinks = null;

        kenntRechts = null;

    }

oder

public Baum(Object pInhalt, Baum pLinks, Baum pRechts)

    {

        kenntInhalt = pInhalt;

        kenntLinks = pLinks;

        kenntRechts = pRechts;

    }

[Ne0Nebul0sa]

In dieser Zeile

return new Baum(inhalt(), fuegeEin(lBaum.linkerTeilbaum(),lVKarte),rechterTeilbaum());

willst du einen neuen Baum erstellen, rufst dabei aber eine Methode auf ("fuegeEin"), welche ein "Ordnungsobjekt" (Kannst du davon den Code posten? Ist das ein Interface/Klasse?) zurückgibt. Der Konstruktor erwartet aber entweder

    public Baum(Object pInhalt)

    {

        kenntInhalt = pInhalt;

        kenntLinks = null;

        kenntRechts = null;

    }

oder

public Baum(Object pInhalt, Baum pLinks, Baum pRechts)

    {

        kenntInhalt = pInhalt;

        kenntLinks = pLinks;

        kenntRechts = pRechts;

    }

Ja, das ist mir klar.. Aber ich suche eine Lösung, ohne den Konstruktor des Baumes zu verändern.. Sprich muss ich meinen jetzigen Code i-wie ändern. Die Klasse Ordnungsobjekt ist ein Interface:

public interface Ordnungsobjekt

{

	// Dienste

	public boolean istGroesserAls(Ordnungsobjekt pObjekt);


	public boolean istKleinerAls(Ordnungsobjekt pObjekt);


	public boolean istGleichWie(Ordnungsobjekt pObjekt);	

}

Entweder ist also mein Gedanke falsch oder ich muss das Ordnungsobjekt überreden, zu einem Baum zu werden (Cast?)

[Aliter]

Ja, das ist mir klar.. Aber ich suche eine Lösung, ohne den Konstruktor des Baumes zu verändern.. Sprich muss ich meinen jetzigen Code i-wie ändern.

Die Klasse Ordnungsobjekt ist ein Interface:

public interface Ordnungsobjekt

{

	// Dienste

	public boolean istGroesserAls(Ordnungsobjekt pObjekt);


	public boolean istKleinerAls(Ordnungsobjekt pObjekt);


	public boolean istGleichWie(Ordnungsobjekt pObjekt);	

}

Entweder ist also mein Gedanke falsch oder ich muss das Ordnungsobjekt überreden, zu einem Baum zu werden (Cast?)

Der Cast würde nicht funktionieren. "fuegeEin" müsste ein Baum zurückgeben, statt ein Ordnungsobjekt. Eigentlich sollte das return in "fuegeEin" schon nicht funktionieren (Typ Baum wird zurückgegeben, Ordnungsobjekt wird aber erwartet).

[Ne0Nebul0sa]

Der Cast würde nicht funktionieren. "fuegeEin" müsste ein Baum zurückgeben, statt ein Ordnungsobjekt. Eigentlich sollte das return in "fuegeEin" schon nicht funktionieren (Typ Baum wird zurückgegeben, Ordnungsobjekt wird aber erwartet).

Ich hab die Klasse heute ein wenig umprogrammiert.. Von der Syntax her passt sie jetzt auch (s.unten).

Die Klasse Visitenkartenanwendung liefert folgenden Fehler: "fuegeEin(Baum,bspg.strukturen.Ordnungsobjekt) in Suchbaum cannot be applied to (Visitenkarte)"

Das liegt offensichtlich daran, dass die Visitenkartenanwendung versucht eine Visitenkarte mitzuliefern, aber die Methode im Suchbaum wie folgt ausschaut:

fuegeEin(Baum lBaum, Ordnungsobjekt pObjekt)

Aber wie verknüpfe ich jetzt die beiden Klassen? Danke nochmals für eure Hilfe! Ne0Nebul0sa Klasse Suchbaum:

import bspg.strukturen.*;

public class Suchbaum

{

  private Baum lBaum;

  public Suchbaum()

  {

    lBaum = new Baum(null);

  }


      private Baum fuegeEin(Baum lBaum, Ordnungsobjekt pObjekt){

           if(!lBaum.istLeer()){

                Ordnungsobjekt wurzel = (Ordnungsobjekt) lBaum.inhalt();

                if(pObjekt.istKleinerAls(wurzel))

                        return new Baum(wurzel,fuegeEin(lBaum.linkerTeilbaum(), pObjekt),lBaum.rechterTeilbaum());

                else if(pObjekt.istGroesserAls(wurzel))

                        return new Baum(wurzel,lBaum.linkerTeilbaum(),fuegeEin(lBaum.rechterTeilbaum(), pObjekt));

                else return lBaum;

           }

           else

                return new Baum(pObjekt);  

      }


      public Visitenkarte insertItem(Ordnungsobjekt pObjekt, Visitenkarte lVisitenkarte) {

          if (lBaum.istLeer())

                 lBaum= new Baum(pObjekt);

          else lBaum = fuegeEin(lBaum, pObjekt);


          return lVisitenkarte; 

      }



      private void loesche(){

          ;

      }


      private void lwr(Baum lBaum, Liste liste){

          if (!lBaum.istLeer()){              

            lwr(lBaum.linkerTeilbaum(),liste);

            liste.fuegeDahinterEin(lBaum.inhalt()); 

            //liste.next();

            lwr(lBaum.rechterTeilbaum(),liste);               

          }

      }


      private Ordnungsobjekt sucheInBaum(Baum lBaum, Ordnungsobjekt pObjekt){

          if (lBaum.istLeer()) return null;

          Ordnungsobjekt root = (Ordnungsobjekt)lBaum.inhalt();

          if (root.istGleichWie(pObjekt)) return root;

          else if (pObjekt.istKleinerAls(root)) return sucheInBaum(lBaum.linkerTeilbaum(),pObjekt);

          else return sucheInBaum(lBaum.rechterTeilbaum(),pObjekt);

      }

    }

Bearbeitet 24. Mai 2012 von Ne0Nebul0sa

[flashpixx]

Ich verweise auf http://de.wikipedia.org/wiki/Vererbung_(Programmierung)

Du solltest Dir ganz dringend Gedanken über die Struktur Deiner Klassen machen. Z.B. ist ein Suchbaum immer noch ein Baum, nur mit bestimmten weiteren Anforderungen, d.h. aber dass der Suchbaum von Baum erbt. Im Normalfall würde man mit Hilfe von Vererbung einmal den Baum aufbauen, zusätzlich erhält ein Objekt, das in den Baum eingefügt wird eine "comparable" Schnittstelle, mit Hilfe man eben prüfen kann, ob ein Objekt größer, kleiner oder gleich ist, damit man in dem Baum richtig einfügen kann.

Sprich Dein Visitenkartenobjekt kann entscheiden, ob es kleiner größer oder gleich einem anderen Visitenkartenobjekt ist. Der Suchbaum erbt alles von Baum und zusätzlich enthält er noch entsprechende Strukturen für die Ordnungsrelation, die wiederum auf die in dem Visitenkartenobjekt hinterlegte Struktur für die Ordnung zurückgreift.

[Ne0Nebul0sa]

Ich verweise auf http://de.wikipedia.org/wiki/Vererbung_(Programmierung)

Du solltest Dir ganz dringend Gedanken über die Struktur Deiner Klassen machen. Z.B. ist ein Suchbaum immer noch ein Baum, nur mit bestimmten weiteren Anforderungen, d.h. aber dass der Suchbaum von Baum erbt. Im Normalfall würde man mit Hilfe von Vererbung einmal den Baum aufbauen, zusätzlich erhält ein Objekt, das in den Baum eingefügt wird eine "comparable" Schnittstelle, mit Hilfe man eben prüfen kann, ob ein Objekt größer, kleiner oder gleich ist, damit man in dem Baum richtig einfügen kann.

Sprich Dein Visitenkartenobjekt kann entscheiden, ob es kleiner größer oder gleich einem anderen Visitenkartenobjekt ist. Der Suchbaum erbt alles von Baum und zusätzlich enthält er noch entsprechende Strukturen für die Ordnungsrelation, die wiederum auf die in dem Visitenkartenobjekt hinterlegte Struktur für die Ordnung zurückgreift.

Das Prinzip der Vererbung ist mir grundsätzlich bekannt. Ich glaube auch nicht, dass dort mein Problem liegt, da ich in einem vorhergegangenen Projekt bereits erfolgreich mit dieser Methode gearbeitet habe. Ich glaube nur, dass ich mich mit dem Baum selbst nochmals Vetraut machen und insbesondere auch meine Handlungsstränge (Struktogramm) protokollieren sollte. Sonst wirkt es ein wenig unstrukturiert und wild.

Vielleicht finde ich ja dann meine Lösung..

Danke jedenfalls für eure Hilfe.

Grüße

Ne0Nebul0sa

Bearbeitet 24. Mai 2012 von Ne0Nebul0sa

[flashpixx]

Das Prinzip der Vererbung ist mir grundsätzlich bekannt. Ich glaube auch nicht, dass dort mein Problem liegt, da ich in einem vorhergegangenen Projekt bereits erfolgreich mit dieser Methode gearbeitet habe.

Warum nutzt Du dann in Deiner Baumklasse eine Klasse "Ordnungsobjekt" und Deine Visitenkartenklasse hat damit nichts zu tun !? Deine Casts in der Klasse sind völlig überflüssig und machen Deinen Code nur unleserlich.

Ich glaube nur, dass ich mich mit dem Baum selbst nochmals Vetraut machen und insbesondere auch meine Handlungsstränge (Struktogramm) protokollieren sollte. Sonst wirkt es ein wenig unstrukturiert und wild.

Wenn Du die Definition des Suchbaumes ( Suchbaum ) wirklich verstanden hättest, dann würdest Du sehen, dass ein Suchbaum nur ein abstraktes Modell ist und sich gar nicht als konkrete implementierte Klasse umsetzen lassen würde, sondern eine konkrete Implementation wäre ein kd-Tree, oder AVL-Tree, ....

Dein kompletter Code ist unstrukturiert und unsystematisch aufgebaut. Es lässt sich nicht wirklich anhand des Codes erkennen, welchen konkreten Baum Du überhaupt implementiert hast. Zusätzlich solltest Du den Code entsprechend layouten, damit er leserlich ist. Du verwendest keine Vererbung innerhalb Deiner Klassen wie z.B. generell Traversierungsmöglichkeiten des Baumes, die dann durch Vererbung entsprechend zur Verfügung stehen. Zusätzlich empfehle ich, dass Du Dich mit den Java Generics ( Generische Programmierung in Java ) vertraut machst, denn damit lassen sich viele Strukturen direkt passend anlegen, so dass Dein Baum z.B. nur Visitenkartenobjekte enthält. Letztendlich sollten 3 Klassen (ggf 4, wenn man mehrere Suchbäume implementieren will) genügen um das Problem zu lösen.

[Ne0Nebul0sa]

Warum nutzt Du dann in Deiner Baumklasse eine Klasse "Ordnungsobjekt" und Deine Visitenkartenklasse hat damit nichts zu tun !? Deine Casts in der Klasse sind völlig überflüssig und machen Deinen Code nur unleserlich.

Wenn Du die Definition des Suchbaumes ( Suchbaum ) wirklich verstanden hättest, dann würdest Du sehen, dass ein Suchbaum nur ein abstraktes Modell ist und sich gar nicht als konkrete implementierte Klasse umsetzen lassen würde, sondern eine konkrete Implementation wäre ein kd-Tree, oder AVL-Tree, ....

Dein kompletter Code ist unstrukturiert und unsystematisch aufgebaut. Es lässt sich nicht wirklich anhand des Codes erkennen, welchen konkreten Baum Du überhaupt implementiert hast. Zusätzlich solltest Du den Code entsprechend layouten, damit er leserlich ist. Du verwendest keine Vererbung innerhalb Deiner Klassen wie z.B. generell Traversierungsmöglichkeiten des Baumes, die dann durch Vererbung entsprechend zur Verfügung stehen. Zusätzlich empfehle ich, dass Du Dich mit den Java Generics ( Generische Programmierung in Java ) vertraut machst, denn damit lassen sich viele Strukturen direkt passend anlegen, so dass Dein Baum z.B. nur Visitenkartenobjekte enthält. Letztendlich sollten 3 Klassen (ggf 4, wenn man mehrere Suchbäume implementieren will) genügen um das Problem zu lösen.

Vielleicht solltest Du nicht vergessen, dass ich mich noch in der Lernphase befinde und das Visitenkartenprojekt eher effektiv als effizient arbeiten sollte.

Das heißt, dass das Programm erst einmal nur laufen muss und später keinen kommerziellen Schwerpunkt hat sondern rein aufgrund des Wunsches zu Lernen entstanden ist. Insofern darf der Code auch ruhig ein wenig wilder ausfallen. Gleichwohl hast Du natürlich Recht, wenn die Grundsätze bereits falsch gelernt werden, überträgt sich das ganze später im beruflichen Leben - aber dann kann ich immernoch meine Lehrerin verantwortlich machen :bimei

Letztlich ist meine Umsetzung auch nur eine Reflektion der Qualität des Unterrrichts, falls ich einem durchschnittlichen Schüler entspreche, und das kann ich bei der Betrachtung der Qualitäten meines Kurses mit einiger Sicherheit sagen :upps.

Ich werde mir deine Kritik zu Herzen nehmen und mir in Ruhe nochmal die angesprochenen Bereiche anschauen.

Wie dem auch sei. Mein Programm sollte eigentlich nur funktionieren, und auch wenn ich konstruktive Kritik schätze und sicherlich angebracht ist, hatte ich mir doch einen Lösungsweg bis zum Ziel erhofft, wie bspw. angestrebt durch den User "Aliter". Danke rechtherzlich dafür.

Vielleicht finde ich ja mit den neuen Erkenntnissen einen Weg.

Defakto ist, dass ich selbst noch lerne und viele Dinge noch nicht kenne. Zumal Java meine erste Progammiersprache ist, die ich aktiv erlerne und seit ca. einem Jahr durch die Schule vermittelt bekomme.

Insofern - nobody's perfect.

Ich wette noch nicht mal Du ;-)

Viele Grüße

Ne0Nebul0sa

Bearbeitet 24. Mai 2012 von Ne0Nebul0sa

[flashpixx]

Man erkennt an Deinem Code, dass Du hier drauflos programmiert hast, anstatt Dir vorher Gedanken zu machen. Die Fehlermeldung, die Dir der Compiler liefert, solltest Du (nach einem Jahr Einarbeitung) interpretieren können, so dass Du die Fehler selbst beheben kannst. Der Code zeigt deutlich, dass Du verschiedene Strukturen der Sprache noch nicht verstanden hast und darum bekommst Du einmal syntaktische Fehler, die Dir der Compiler meldet, aber wie Dein Code zeigt auch eine Menge semantische Fehler, die Dir der Compiler nicht meldet, die aber letztendlich zu einem nicht korrekt funktionierenden Code führen.

Es gehört beim Programmieren dazu, dass man sich, bevor man sich Gedanken über den Code macht, zunächst Gedanken über den Algorithmus macht und wie schon angemerkt sind bei Dir dort noch einige Diskrepanzen.

Das heißt, dass das Programm erst einmal nur laufen muss und später keinen kommerziellen Schwerpunkt hat sondern rein aufgrund des Wunsches zu Lernen entstanden ist. Insofern darf der Code auch ruhig ein wenig wilder ausfallen. Gleichwohl hast Du natürlich Recht, wenn die Grundsätze bereits falsch gelernt werden, überträgt sich das ganze später im beruflichen Leben - aber dann kann ich immernoch meine Lehrerin verantwortlich machen :bimei

ah ja und was nützt das, wenn Du etwas falsch gelernt hast? Lehrer dafür verantwortlich machen, bringt keinen Nutzen. Mir ist schon klar, dass es hier um eine Lernaufgabe geht und das was ich angemerkt habe bewegt sich nicht in einem "kommerziellen" Schwerpunkt, sondern es sind Grundlagen, die man bei der Sprache Java beherrschen muss.

Wie dem auch sei. Mein Programm sollte eigentlich nur funktionieren, und auch wenn ich konstruktive Kritik schätze und sicherlich angebracht ist, hatte ich mir doch einen Lösungsweg bis zum Ziel erhofft, wie bspw. angestrebt durch den User "Aliter". Danke rechtherzlich dafür.

Aliter hat Dir die Symptome behoben, Dein Code ist dadurch aber nicht besser geworden. Im Grunde ist diese Lösung ein Heftpflaster und keine Lösung des Problems. Wenn Dir, wie in Deinem letzten Posting gesagt hast,

Das Prinzip der Vererbung ist mir grundsätzlich bekannt. Ich glaube auch nicht, dass dort mein Problem liegt, da ich in einem vorhergegangenen Projekt bereits erfolgreich mit dieser Methode gearbeitet habe.

Vererbung bekannt ist, dann darf wohl die fachliche Frage berechtigt sein, warum nutzt Du sie dann nicht und baust hier eine komplexe und unübersichtliche Codestruktur auf, die nicht notwendig ist.

Ich wette noch nicht mal Du ;-)

Ich entsinne mich nicht, das innerhalb des Thread gesagt zu haben. Ich habe Dich lediglich darauf hingewiesen, dass einige fachliche Fehler in Deinem Entwurf sind und Du auf der einen Seite anscheinend Dinge kennst, sie aber nicht anwendest. Dies ist eine rein fachliche Einschätzung. Ich erhebe sicherlich nie den Anspruch an Fehlerfreiheit, das wäre unmöglich, aber ich bin durchaus bereit verschiedene Lösungen zu überdenken. Wie schon geschrieben, kommt es nicht darauf, dass es "irgendwie ein lauffähiges Programm gibt", sondern es kommt darauf an, wie man zu der Lösung kommt und aufgrund meiner Erfahrungen und auch aufgrund meines Wissen, sei Dir hier nur der Hinweis gegeben, dass es meist sinnvoller ist, zunächst mit Stift und Papier z.B. ein OOP Modell zu entwickeln und zu skizzieren und dann zu überlegen, wie man das in der jeweiligen Sprache sinnvoll umsetzt. Z.B. hättest Du Dir einfach mal die Container Klasse von Java (ArrayList, Vector, ...) und die Comparable-Schnittstelle anschauen können, denn das wäre genau das, was Du hier anhand der Aufgabenstellung hättest machen sollen. Ich würde schätzen, dass Du nur 10% Deines jetzigen Codes brauchen würdest, um das Problem zu lösen, das Wissen steckt dann aber in dem Algorithmus und der Struktur.

[Ne0Nebul0sa]

Man erkennt an Deinem Code, dass Du hier drauflos programmiert hast, anstatt Dir vorher Gedanken zu machen

Nichts anderes hab ich behauptet ;-)

Ferner kann ich die Fehlermeldung interpretieren (s. Begründungen bei den einzelnen Fehlern); doch hin und wieder fehlen mir die Lösungswege - die Lösungsansätze sind vorhanden.

Ich dachte hier eigentlich neben der Hilfe auch konstruktive Kritik zu erhalten. Anfangs hattest Du diese auch noch gegeben, aber Aussagen wie

solltest Du (nach einem Jahr Einarbeitung) interpretieren können

sind meiner Aufassung nach weder konstruktiv noch hilfreich und rein persönlich bezogen (wenn auch wie in diesem Fall nicht allzu dramatisch).

Zu Bewerten wie weit und wie intensiv ich etwas erlerne, liegt, finde ich, nicht in der Relevanz für die Frage. Solche Aussagen helfen niemand weiter und je drastischer die Formulierung, desto sinnloser die Aussage.

Nun zu argumentieren ich könnne keine Kritik vertragen wäre ebenso nicht nachvollziehbar. Ich habe mehrmals unterstreicht, dass ich meine Fehler versuchen werde zu beheben und darum gebeten, wenn auch indirekt, dass sich jeder dessen bewusst sein sollte.

Umso trauriger finde ich es, wenn sich ein Moderator - seines Ranges und der damit verbundenden Verantwortung bewusst - dann dazu äußert.

Wenn ich deinen oder den allgemeinen Anforderungen nicht genüge, dann ist das leider meine Schwäche.

Ich möchte hier keinen Konflikt anzetteln, aber da sicherlich viele hobbymäßig im Forum unterwegs sind (und möglicherweise beruflich programmieren), erhoffe ich einen gewissen Spaßfaktor bei der Sache.

Ich möchte darauf aber auch nicht zu sehr herumreiten.

Deine Kritik, sofern konstruktiv, ist angebracht und berechtigt.

Vererbung bekannt ist, dann darf wohl die fachliche Frage berechtigt sein, warum nutzt Du sie dann nicht und baust hier eine komplexe und unübersichtliche Codestruktur auf, die nicht notwendig ist.

Um einmal die Katze aus dem Sack zu lassen: Ich habe nach dem Programm online gesucht, da es Teil der schulbezogenen Programmierung ist und ich ferner nicht der erste sein sollte, der sich damit befasst hat. So habe ich hier ein Beispiel gefunden, das Programm kopiert und auf meine Bibliothek angepasst.

Insofern ist meine Aussage

Die Methoden "sortiereListe","suche" und "fuegeEin" sind selbst programmiert

so gesehen nicht korrekt. Ich habe den Code lediglich modifiziert.

Diskrepanzen

..aus Faulheit und teilweise nicht vorhandenen Wissen (deshalb auch die berechtigte Kritik).

Zudem habe ich manchmal das Gefühl, dass Du meine Antworten nicht richtig liest, denn:

ah ja und was nützt das, wenn Du etwas falsch gelernt hast?

habe ich bereits angeführt mit:

Gleichwohl hast Du natürlich Recht, wenn die Grundsätze bereits falsch gelernt werden, überträgt sich das ganze später im beruflichen Leben

Der Satz

aber dann kann ich immernoch meine Lehrerin verantwortlich machen :bimei

war ein Zusatz um die Atmosphäre ein wenig zu lockern - daher auch der Smiley.

Nachdem ich weiter oben bereits gesagt hatte, warum der Code so aufgebaut ist, hat sich diese Frage auch geklärt:

[..]Vererbung bekannt ist, dann darf wohl die fachliche Frage berechtigt sein, warum nutzt Du sie dann nicht und baust hier eine komplexe und unübersichtliche Codestruktur auf, die nicht notwendig ist.

Was ich noch anführen wollte ist folgendes:

Ich entsinne mich nicht, das innerhalb des Thread gesagt zu haben.

Was vollkommen korrekt ist. Ich hatte den Satz auch nur als einen Hinweis - Tipp angeführt. Ich hatte gehofft damit ein Signal versendet zu haben.

Denn auch wenn Deine Kritik (größtenteils) angebracht ist, so wirkst Du für mich leider ein bischen "hochnäsig" oder vorsichtiger wie ein "Mann des leichten Wortes", was ich persönlich sehr schade finde, denn meiner Meinung nach ist der Moderator (und der Administrator, bzw. die leitende Gruppe) das Vorbild für jedes Mitglied.

Container Klasse von Java (ArrayList, Vector, ...) und die Comparable-Schnittstelle[...]was Du hier anhand der Aufgabenstellung hättest machen sollen

Auch wenn ich rein fachlich nicht beurteilen kann, ob Du Recht hast, so war es nicht in der Aufgabenstellung gefordert. Weder direkt noch indirekt. Die Schnittstelle (Interface) sollten wir uns allerdings sehr wohl anschauen - was meiner Ansicht nach der von Dir angsprochene Punkt ("Comparable-Schnittstelle") entspricht?

Rein gedanklich habe ich mir inzwischen folgendes überlegt:

Zunächst wird abgefragt, ob der Baum leer ist, um einen möglichen NullPointer zu vermeiden.

Falls ja: Es wird ein neuer Baum erzeugt.

Falls nein: Überprüfe, ob Teilbäume existieren (bzw. nicht leer sind).

Nun wird gefragt, ob die vorliegende Visitenkarte größerAls die im Baum liegende Visitenkarte (Ordnungsobjekt) ist.

Falls nein & nicht gleich der aktuellen & und das Blatt nicht gleich null: linker Teilbaum.

Falls nein & gleich der aktuellen: Methode gleichWie aufrufen.

Falls ja und das Blatt nicht gleich null: gehen einen Schritt in den rechten Teilbaum.

--Falls das Blatt gleich null & nicht gleich der akteullen Karte: lege Karte ab und lösche aktuelle Visitenkarte aus der Liste. (gilt sowohl für den rechtenTB als auch für den linkenTB).

Methode GleichWie:

lösche Karte. (,da sonst doppelt existent)

Falls wir am Ende sind (keine Visitenkarte mehr vorhanden):

Programm durchgelaufen. Ende.

Nun gut. Lediglich ein paar Gedanken für das Programm. Die Methoden "istGleichWie", "istGroesserAls" und "istKleinerAls" kann ich ja mit Hilfe der Schnittstelle benutzen.

Verbesserungsvorschläge gerne gesehen :cool:

Viele Grüße

Ne0Nebul0sa

Bearbeitet 25. Mai 2012 von Ne0Nebul0sa

[Carl]

Hallo,

wenn ich richtig verstanden habe, möchtest du die Methoden einfügen, contains, und traversieren programmieren. Das in-Order Traversieren gibt eine sortierte Liste aller enthaltenen Elemente zurück.

Hier mal ein kleiner Ansatz der dir vielleicht hilfreich sein kann

public class Tree<E extends Comparable<E>> {

    protected Tree<E> right, left;

    protected E element;


    public Tree(E element) {

        this.element = element;

    }


    public void insert(E element)

    {

        if (this.element.compareTo(element) < 0) 

        {

            if (left != null) 

            {

                left.insert(element);

            } 

            else 

           {

                left = new Tree<E>(element);

            }


        } 

        else 

        {

            if (right != null) 

            {

                right.insert(element);

            } 

            else 

            {

                right = new Tree<E>(element);

            }

        }

    }


    public boolean contains(E element)

    {

        if (element.equals(element)) 

        {

            return true;

        }

        else 

        {

            if (this.element.compareTo(element) < 0) 

            {

                if (left != null) 

                {

                    return left.contains(element);

                }

                else 

                {

                    return false;

                }

            }

           else 

            {

                if (right != null) 

                {

                    return right.contains(element);

                } 

                else 

                {

                    return false;

                }

            }

        }

    }


    public java.util.LinkedList<E> sortiere()

    {

        java.util.LinkedList<E> erg = new java.util.LinkedList<E>();

        if(left!=null)erg.addAll(left.sortiere());

        erg.add(element);

        if(right!=null)erg.addAll(right.sortiere());

        return erg;

    }


}

Die Klasse Baum die du oben vorgestellt hast ist nicht wirklich gut, denn die Attribute müssten protected sein, damit du ja in deiner Klasse Suchbaum einfach auf den linken bzw. rechten Teilbaum zugreifen kannst, ohne über diese verrückten getter Methoden darauf zugreifen zu müssen.

Sinnvoll könnte es sein, den Suchbaum als AVL-Baum zu programmieren, da dieser effizient ist in der Suche. Hier wird immer eine Ordnung eingehalten, dass heißt das beim Einfügen/Löschen immer geguckt wird, ob die balance noch gegeben ist um dann evtl. diese durch Rotationen wiederherzustellen.

Bearbeitet 26. Mai 2012 von Carl

[Carl]

Um ein Element zu finden, ist es sinnfrei den Baum erst durch die In-Order Traversierung in einer sortierte Liste zu verwandeln um diese dann anschließend nach dem gesuchten Objekt zu durchsuchen. Hier reicht der Code der Methode contains aus. An der Stelle wo dort return true steht ist das Element gefunden worden. Es ist besser deinen Suchbaum nicht von der Klasse Baum abzuleiten und direkt eine eigene Klasse Baum zu schreiben, die dem Grundgerüst der obigen Klasse entspricht.

[Ne0Nebul0sa]

Den Teil

this.element.compareTo(element) < 0

verstehe ich nicht ganz. Müsste dieser nicht genau anders herum sein? Denn bisher wird verglichen, ob das aktuelle Element verglichen mit dem anderen Element kleiner 0 ist?

Die Methode "sortiere" wird höchstwahrscheinlich den Baum anhand eines Algorithmus sortieren, nicht wahr?

Die Klasse Baum die du oben vorgestellt hast ist nicht wirklich gut, denn die Attribute müssten protected sein, [..]

Ist interessanterweise eine Musterlösung. Aber danke für den Hinweis.

Sinnvoll könnte es sein, den Suchbaum als AVL-Baum zu programmieren, da dieser effizient ist in der Suche. Hier wird immer eine Ordnung eingehalten, dass heißt das beim Einfügen/Löschen immer geguckt wird, ob die balance noch gegeben ist um dann evtl. diese durch Rotationen wiederherzustellen.

Verstehe ich noch nicht ganz (aufgrund der Wortwahl), davon wird aber auch erst später Gebrauchst gemacht - zumindest ist hiervon noch keine Rede im Lehrbuch.

Um ein Element zu finden, ist es sinnfrei den Baum erst durch die In-Order Traversierung in einer sortierte Liste zu verwandeln um diese dann anschließend nach dem gesuchten Objekt zu durchsuchen. Hier reicht der Code der Methode contains aus.

Danke.

An der Stelle wo dort return true steht ist das Element gefunden worden.

Naheliegend.

Es ist besser deinen Suchbaum nicht von der Klasse Baum abzuleiten und direkt eine eigene Klasse Baum zu schreiben, die dem Grundgerüst der obigen Klasse entspricht.

Okay, danke - Darf ich fragen, weswegen Du den Gedanken angebracht hast?

[Carl]

Die Methode public int compareTo des Interfaces Comparable musst du eh selbst in deiner Klasse Visitenkarte programmieren. -1 wird zurückgegebn wenn es kleiner ist 0 wenn gleich und 1 wenn größer. Kann sein, dass ich mich da vertan habe.

Bei der Klasse Baum, von der du ableitest hast du das Problem, dass du ja nicht dirkt über this.kenntlinks auf den linken Teilbaum zugreifen kannst. Dies sollte man protected machen, damit du in deiner Klasse SuchBaum darauf zugreifen kannst.

Erstmal ist die Klasse Baum kein Baum sondern ein Binärbaum. Oben in meinem Beispiel siehst du z.B. in der Methode einfügen, dass ich direkt mit this.left!=null oder this.element auf die nötigen Attribute zugreifen kann. Dies vereinfacht die Arbeit ungemein. Zweitens ist dort ein generischer Ansatz gewählt worden, dass heißt, dass du später jede Klasse die das Interface Comparable implementiert in diesen SuchBaumContainer reinstecken kannst.

Bezüglich AVL-Bäume: Natürlich brauchst du dich im ersten Moment nicht darum kümmern. Aber betrachte folgenden fall:

Du fügst die Elemente 20,15,10,5 und 25 ein der Reihenfolge ein, dann sieht der normale Baum so aus:

20

15 25

10

5

Du siehst dass der Baum die Tiefe 4 hat. Ein AVL-Baum würde jetzt eine Rotation durchführen sodass die Tiefe nur noch 3 wäre, dass heißt nur noch 3 anstatt 4 Schritte um zu suchen. Geh einfach mal auf Wikipedia AVL Baum

Gruß Carl

[Carl]

Du könntest das Sortieren/In-Order Traversieren zur veranschaulichung auch anders gestalten:

public void printOut()

{

         this.left.printOut();

         System.out.print(this.element.toString()+";");

         this.right.printOut();

}

Hier werden die Elemente in sortierter Reihenfolge auf der Konsole ausgegeben.

Schau dir vielleicht auch nochmal das Traversieren bei Wikipedia an.

[Ne0Nebul0sa]

Die Methode public int compareTo des Interfaces Comparable musst du eh selbst in deiner Klasse Visitenkarte programmieren. -1 wird zurückgegebn wenn es kleiner ist 0 wenn gleich und 1 wenn größer. Kann sein, dass ich mich da vertan habe.

Die Methode gibts übrigens bereits. Insofern fällt das bei mir weg. Mit der Rückgabe bin ich aber auch nicht so sicher, deshalb auch meine Rückfrage.

Bei der Klasse Baum, von der du ableitest hast du das Problem, dass du ja nicht dirkt über this.kenntlinks auf den linken Teilbaum zugreifen kannst. Dies sollte man protected machen, damit du in deiner Klasse SuchBaum darauf zugreifen kannst.

Alles klar, danke.

[..]. Oben in meinem Beispiel siehst du z.B. in der Methode einfügen, dass ich direkt mit this.left!=null oder this.element auf die nötigen Attribute zugreifen kann. Dies vereinfacht die Arbeit ungemein. Zweitens ist dort ein generischer Ansatz gewählt worden, dass heißt, dass du später jede Klasse die das Interface Comparable implementiert in diesen SuchBaumContainer reinstecken kannst.

Doppelt gut. Eigentlich sollte ich solche Dinge doch nach einem Jahr bereits vermittelt bekommen haben, nicht wahr?

Du siehst dass der Baum die Tiefe 4 hat. Ein AVL-Baum würde jetzt eine Rotation durchführen sodass die Tiefe nur noch 3 wäre, dass heißt nur noch 3 anstatt 4 Schritte um zu suchen. Geh einfach mal auf Wikipedia AVL Baum

Okay, also quasi eine Art Komprimierung. Ähnlich dem Huffmann-Algorithmus, bloß dass dieser überflüssigen (leeren) Speicher neu besetzt, solange das Gleichgewicht gewährt ist.

Erscheint logisch. Traversierung in Inorder-Ausgabe. Eine bisher simple Sache.

[Carl]

Nee mit dem Huffmann Algorithmus hat das gar nichts zu tun. Der Huffmann Algorithmus komprimiert ja nur. Stell die vor du würdest die Zahlen 1,2,3,4,5,6,7,8,9,10,11,12 nacheinander in deinen Suchbaum einfügen. Dann würde ja immer rechts eingefügt werden und du hättes eine Tiefe von 12. Dass heißt bis du die 11 gefunden hast brauchst du schon 11 Schritte. Ein AVL-Baum würde nach jedem einfügen prüfen ob die Balance gegeben ist.

z.B. würde er nachdem 1,2,3 eingefügt wurde eine Rotation durchführen, sodass 2 die Wurzel wird und 1 links sowie 3 rechts wäre. Hier wird nichts komprimiert sondern eine geometrische Ordnung wiederhergestellt. Diese Rotation wird durchgeführt weil die Wurzel die Balance +2 hat, dass heißt das 1(Wurzel) einen rechten hat(2) der wiederum einen rechten hat(3) wohingegen keiner links ist. Nach der Rotation ist die Balance 0 da die Wurzel(2) einen linken (1) und einen rechten(3) hat. Für jeden linken gibt - Punkte und für jeden rechten + Punkte. (-1) + (+1) ist null.

Du solltest vielleicht zunächst mal eine Methode schreiben, die die Tiefe des Baumes berechnet. Denn die Tiefe des Baumes ist auch die maximale Anzahl Schritte die benötigt werden zum suchen.

Du hast ja ein Interface Ordnungsobjekt geschrieben, das ist auch gut wie du das gemacht hast. Es ist allerdings sinnvoller, die von Java mitgelieferten Standards(Comparable) zu nutzen.

class Tree<E extends Comparable<E>> { ...}

class VisitenKarte implements Comparab<Visitenkarte>

{

         public int compareTo(Visitenkarte visitenkarte)

        {

             wenn this.visitenkarte kleiner visitenkarte ->-1

             wenn this.visitenkarte gleicht visitenkarte ->0

            wenn this.visitenkarte größer visitenkarte ->1

        }

}

public static void main(String args[])

{

           Tree<Visitenkarte> visitenkarten;


}

Bearbeitet 27. Mai 2012 von Carl

[Ne0Nebul0sa]

[...] Hier wird nichts komprimiert sondern eine geometrische Ordnung wiederhergestellt. [..]

Alles klar. Da lag mein gedanklicher Fehler.

[...] Du hast ja ein Interface Ordnungsobjekt geschrieben, das ist auch gut wie du das gemacht hast. Es ist allerdings sinnvoller, die von Java mitgelieferten Standards(Comparable) zu nutzen. [..]

Danke. Allerdings habe ich die Schnittstelle nicht selbst programmiert, sondern quasi vorgelegt bekommen. Aber ich werde meine Lehrerin mal darauf ansprechen.

Danke jedenfalls schonmal. Ich werde mit Java generell erst einmal einige Schritte nach hintne machen, wie flashpixx es empfohlen hat.

Viele Grüße

Ne0Nebul0sa