Einrücken inner der toString()-Methode

[Easyik]

Hey,

ich bin gerade dabei mir die einzelnen Knoten eines Baumes ausgeben ausgeben zu lassen.
Soweit klappt es ganz gut, jedoch wollte ich gerne etwas mit der Struktur der Ausgabe rumspielen und hätte diesbezüglich fragen 🙃
Gewollt wäre eine Ausgabe nach folgendem Muster :

[wurzel]--->[linkerKnoten]--->[links.linkerKnoten]......
[                        ]--->[links.rechterKnoten].....
[      ]--->[rechterKnoten]--->[rechts.linkerKnoten].....
[                         ]--->[rechts.rechterKnoten].....

die einzelnen [] gehören untereinander, leider wird dies automatisch nach links verschoben -.-

public String toStringtest(){
    String result = inhalt;
    if(links==null){
        result=result+"\t Links ist unbekannt---";
    }
    if(links!=null){
        result=result+"\t"+links.toStringtest();
    }

    if(rechts==null){
        result= result+"\n \tRechts ist unbekannt---";
    }

     if(rechts!=null){
        result=result+"\n \t"+rechts.toStringtest();
    }

    return result;
}

solange es bei einem linken und einem rechten Zweig bleibt passt es ja....

bin offen für jede art von Ratschlag

 

[fhoffmann]

Ich würde dir eher folgende Ausgabe empfehlen:

[wurzel]
--->[linkerKnoten]
--->--->[links.linkerKnoten]
--->--->[links.rechterKnoten]
--->[rechterKnoten]
--->--->[rechts.linkerKnoten]
--->--->[rechts.rechterKnoten]

Dazu kannst du deiner Methode toStringtest() einen Parameter mitgeben, also toStringtest(int anzahlEinrueckungen).

 

[Easyik]

Ich würde dir eher folgende Ausgabe empfehlen:

[wurzel]
--->[linkerKnoten]
--->--->[links.linkerKnoten]
--->--->[links.rechterKnoten]
--->[rechterKnoten]
--->--->[rechts.linkerKnoten]
--->--->[rechts.rechterKnoten]

Dazu kannst du deiner Methode toStringtest() einen Parameter mitgeben, also toStringtest(int anzahlEinrueckungen).

Schaut auch Interessant aus, allerdings geht es mir jetzt primär dadrum diese erste Idee erstmal umzusetzen.
Danach würde ich mich gerne an deiner empfohlenen Struktur versuchen

 

[fhoffmann]

allerdings geht es mir jetzt primär dadrum diese erste Idee erstmal umzusetzen.

Deine ursprüngliche Idee umzusetzen ist ziemlich kompliziert.
Du kannst nie wissen, wo ein Tabulator, vor dem noch Text steht, landet.

 

[Easyik]

um es nochmal etwas deutlicher zu gestaltet:

[wurzel]--->[linkerKnoten]--->[links.linkerKnoten]
                          --->[links.rechterKnoten]
        --->[rechterKnoten]--->[rechts.linkerKnoten]
                           --->[rechts.rechterKnoten]

 

[Easyik]

Deine ursprüngliche Idee umzusetzen ist ziemlich kompliziert.
Du kannst nie wissen, wo ein Tabulator, vor dem noch Text steht, landet.

Die Erfahrung mache ich jetzt gerade auch XD

wäre es möglich die länge eines Baumes zu ermitteln?

 

[fhoffmann]

wäre es möglich die länge eines Baumes zu ermitteln?

Du kannst natürlich die Länge eines Strings ermitteln. Aber wenn alle Kinder, Enkel, Urenkel, Ururenkel des root-Knotens untereinander stehen sollen, musst du zunächst deinen Baum durchgehen und die maximale Länge jeder Generation feststellen. Erst dann kannst du den Baum malen. Das wird - wie gesagt - ziemlich kompliziert.
Deshalb mein Tip, jedem Knoten eine eigene Zeile zu gönnen.

 

[Easyik]

Ich werde es mal versuchen

 

[Easyik]

Ich würde dir eher folgende Ausgabe empfehlen:

[wurzel]
--->[linkerKnoten]
--->--->[links.linkerKnoten]
--->--->[links.rechterKnoten]
--->[rechterKnoten]
--->--->[rechts.linkerKnoten]
--->--->[rechts.rechterKnoten]

Dazu kannst du deiner Methode toStringtest() einen Parameter mitgeben, also toStringtest(int anzahlEinrueckungen).

wie kriege ich das hin das beim hochzählen einer Variable, das einrücken um eins erhöht wird?

 

[fhoffmann]

wie kriege ich das hin das beim hochzählen einer Variable, das einrücken um eins erhöht wird?

Du rufst die Methode für den root-Knoten mit toStringtest(0) auf und rufst dann innerhalb der Methode toStringtest(anzahlEinrueckungen + 1) auf.
Und innerhalb der Methode schreibst du (in einer for-Schleife) soviele Tabulatoren wie benötigt.

 

[Easyik]

So das wäre der aktuelle Code:

public String einruecken(int anzahleinzurückendeStellen){
    String einrueckungen="";
    for(int i=0;i<=anzahleinzurückendeStellen;i++){
        einrueckungen=einrueckungen+"\t";
    }
    return einrueckungen;
}


public String toStringtest(){
    String result = inhalt;
   
    int n=0;
    if(links==null){
       
        result=result+"\t"+"links ist unbekannt";
    }
    if(links!=null){
        result=result+"\t"+links.toStringtest();
     
    }

    if(rechts==null){
       
        result=result+"\n"+einruecken(n)+"rechts ist unbekannt";
    }
   
   
    return result;
}

Ich bräuchte einen Tipp wie ich die Variable n um eins erhöhen könnte, gewünscht wäre es das beim Aufruf der toStringtest-Methode keine Eingabe erfolgen muss.

Eine weitere Frage wäre, ob nach dem Selbstaufruf der Methode toStringtest(), erstmal an dieser stelle der Code abgebrochen wird oder davor nochmal ganz durchlaufen wird.... ich hoffe ich konnte es richtig ausdrücken.

Und wie immer gilt bin für jeden Ratschlag offen und dankbar 🙃

 

[kneitzel]

Was @fhoffmann vorgeschlagen hat, ist ja:
Das n wird als Parameter übergeben. Es ist also keine lokale Variable wie bei Dir.

Das bedeutet dann also für Dich und Deine Ausgabe:
a) Deine Methode public String toStringtest() macht nichts anderes, als die toStringtest Methode mit Parameter aufzurufen, also sowas:

public String toStringtest() {
    return toStringtest(0); // Hier noch evtl. die "magic number" in eine Konstante verbannen!
}

b) In der Methode kannst Du dann bei allen rekursiven Aufrufen statt n ein n+1 mitgeben. Aus dem Code: links.toStringtest(); wird dann links.toStringtest(n+1);

Ansonsten habe ich mir jetzt im Detail Deine einrücken-Methode nicht angesehen und so. Aber du musst den Code bei links vermutlich mit dem einrücken machen - also ähnlich, wie Du es bei rechts schon hast wobei da der rekursive Aufruf fehlt.

Ansonsten noch ein Hinweis zur Vereinfachung des Codes:

if (a) {
    // ....
}

if (!a) {
    // ...
}

solltest Du einfach schreiben als:

if (a) {
    // ...
} else {
    // ...
}

Der else Zweig ist ja genau das !a Pendant. Eine neue Prüfung ist da ja nicht notwendig.

 

[Easyik]

Erstmal vielen dank für die ganze Hilfe.

Soweit scheint es jetzt zu klappen, wobei ich der ersten Struktur sehr nahe gekommen bin.

 

[kneitzel]

Der Code von links und rechts sollte vom prinzip gleich sein, da ja bei beidem eigentlich das gleiche gemacht wird (bis auf eben links durch rechts ersetzt).

Da ist es aber unterschiedlich. Du kannst also schauen, was an der Ausgabe richtig bzw. falsch ist um dann den Code entsprechend anzupassen.

 

[Easyik]

dadurch wird bei mit gerade ein anderer Fehler deutlich.
Allem Anschein nach befülle ich nur den ganz rechten bzw den ganz linken Zweig mit Informationen.

hätte da jemand auch einen Tipp für mich?

public void insert(String eingabe,int status){
    if(links==null ){
        links=new Knoten(eingabe,status);
    } else if(links!=null){
        links.insert(eingabe,status);
    }

    if(rechts==null){
        rechts=new Knoten(eingabe,status);
    }else if( rechts!=null){
        rechts.insert(eingabe,status);
    }
}

bin für Ratschläge und Tipps offen.
Danke schon mal im Voraus.

 

[kneitzel]

Da fehlt die Logik, wo etwas eingefügt werden soll.

Daher ist es beim insert so, dass Du etwas mindestens doppelt einfügst. links und rechts null: Erst wird ein neuer Knoten Links eingefügt, dann auch noch rechts.

Eine Logik kann z.B. eine Sortierung sein:
Du vergleichst eingabe mit dem Wert des aktuellen Knotens. Davon abhängig entscheidest Du ob es links oder rechts eingefügt werden soll. Das geht dann in Richtung Binary Search Tree.

 

[Easyik]

Da fehlt die Logik, wo etwas eingefügt werden soll.

Daher ist es beim insert so, dass Du etwas mindestens doppelt einfügst. links und rechts null: Erst wird ein neuer Knoten Links eingefügt, dann auch noch rechts.

Eine Logik kann z.B. eine Sortierung sein:
Du vergleichst eingabe mit dem Wert des aktuellen Knotens. Davon abhängig entscheidest Du ob es links oder rechts eingefügt werden soll. Das geht dann in Richtung Binary Search Tree.

ist dies auch umsetzbar wenn man keine zahlen verwenden will

 

[kneitzel]

ist dies auch umsetzbar wenn man keine zahlen verwenden will

Das ist generell möglich, so man Elemente vergleichen kann.

Das, was hier ins Spiel kommt, ist das Comparable Interface, dass eine compareTo Methode vorsieht.

Dies findet man dann z.B. auch in String, der eben Comparable<String> implementiert:

String (Java SE 17 & JDK 17)

declaration: module: java.base, package: java.lang, class: String

docs.oracle.com

Damit kann man dann zwei gespeicherte Werte vergleichen und bekommt auch dieses "größer" / "kleiner" bei den Elementen.

Das nennt sich dann auch "natürliche Ordnung" (natural Order).

Generell kann man aber auch eine beliebige Sortierung vornehmen. Da dies aber dann nicht die natürliche Ordnung ist, gehört es nicht mehr zu der Klasse selbst. Die Klasse implementiert also kein Interface dafür. Es ist etwas, das von außen angegeben und bestimmt wird:
Die Anordnung von Gegenständen auf deinem Schreibtisch wären ein Beispiel:
- Natürliche Ordnung gibt es nicht - kann man sich mein Schreibtisch ansehen: Alles liegt so, wie ich oder meine Katze es hinterlassen haben.
- Wenn man jetzt Ordnungsfanatiker hat, dann sortieren die: Einer sortiert alles nach Farbe. Der Farbverlauf muss ein ganz bestimmter sein. Ein anderer will alles nach Größe sortiert haben.... wieder ein Anderer hat ganz andere Ideen. Von mir aus Links alles, was gut desinfiziert ist und alles, was irgendwie berührt wurde muss rechts sein - bereit zum nächsten Desinfizieren.... Das ist also nichts, das durch die Gegenstände bestimmt wird sondern von außen.

Somit ist klar, dass es eine eigenständige Klasse zur Sortierung wird. Und damit die Benutzung klar ist, gibt es ein klares Interface: Comparator<T>.

Das wäre die zweite Möglichkeit. Bei der muss dann aber von Außen ein Comparator mitgegeben werden.

Somit hätte man bei Generics zwei Pattern:

public class WhatEver<T extends Comparable<T>> {
    public WhatEver() {
        // ...
    }
}


public class WhatEver<T> {
    public WhatEver(Comparator<T> comparator) {
        // ...
    }
}

Das erste WhatEver zeigt: Es können nur Elemente genutzt werden, die eine natürliche Ordnung haben.
Das zweite WhatEver zeigt: Es können beliebige Elemente genutzt werden, es muss keine natürliche Ordnung geben. Aber dafür muss ich bei der Erstellung ein Comparator mitgeben.

Das wäre die etwas längere Erläuterung. Ich hoffe, ich konnte damit mehr erklären als Fragezeichen zu hinterlassen

 

[Easyik]

Das ist generell möglich, so man Elemente vergleichen kann.

Das, was hier ins Spiel kommt, ist das Comparable Interface, dass eine compareTo Methode vorsieht.

Dies findet man dann z.B. auch in String, der eben Comparable<String> implementiert:

String (Java SE 17 & JDK 17)

declaration: module: java.base, package: java.lang, class: String

docs.oracle.com

Damit kann man dann zwei gespeicherte Werte vergleichen und bekommt auch dieses "größer" / "kleiner" bei den Elementen.

Das nennt sich dann auch "natürliche Ordnung" (natural Order).

Generell kann man aber auch eine beliebige Sortierung vornehmen. Da dies aber dann nicht die natürliche Ordnung ist, gehört es nicht mehr zu der Klasse selbst. Die Klasse implementiert also kein Interface dafür. Es ist etwas, das von außen angegeben und bestimmt wird:
Die Anordnung von Gegenständen auf deinem Schreibtisch wären ein Beispiel:
- Natürliche Ordnung gibt es nicht - kann man sich mein Schreibtisch ansehen: Alles liegt so, wie ich oder meine Katze es hinterlassen haben.
- Wenn man jetzt Ordnungsfanatiker hat, dann sortieren die: Einer sortiert alles nach Farbe. Der Farbverlauf muss ein ganz bestimmter sein. Ein anderer will alles nach Größe sortiert haben.... wieder ein Anderer hat ganz andere Ideen. Von mir aus Links alles, was gut desinfiziert ist und alles, was irgendwie berührt wurde muss rechts sein - bereit zum nächsten Desinfizieren.... Das ist also nichts, das durch die Gegenstände bestimmt wird sondern von außen.

Somit ist klar, dass es eine eigenständige Klasse zur Sortierung wird. Und damit die Benutzung klar ist, gibt es ein klares Interface: Comparator<T>.

Das wäre die zweite Möglichkeit. Bei der muss dann aber von Außen ein Comparator mitgegeben werden.

Somit hätte man bei Generics zwei Pattern:

public class WhatEver<T extends Comparable<T>> {
    public WhatEver() {
        // ...
    }
}


public class WhatEver<T> {
    public WhatEver(Comparator<T> comparator) {
        // ...
    }
}

Das erste WhatEver zeigt: Es können nur Elemente genutzt werden, die eine natürliche Ordnung haben.
Das zweite WhatEver zeigt: Es können beliebige Elemente genutzt werden, es muss keine natürliche Ordnung geben. Aber dafür muss ich bei der Erstellung ein Comparator mitgeben.

Das wäre die etwas längere Erläuterung. Ich hoffe, ich konnte damit mehr erklären als Fragezeichen zu hinterlassen

Gerade überwiegen die Fragezeichen, jedoch weiß ich jetzt wo ich muss noch einlesen muss.
Danke sehr.

 

[kneitzel]

Gerade überwiegen die Fragezeichen, jedoch weiß ich jetzt wo ich muss noch einlesen muss.
Danke sehr.

Und nicht vergessen: Du kannst auch hier weiter fragen - niemand ist böse, wenn etwas nicht verstanden wird und Erklärungen, die so auf die Schnelle hin geschrieben werden, sind oft nicht optimal. (Ist ein bekanntes Manko - da müsste ich ggf. noch mehr an mir arbeiten. Da müsste ich mir ein Beispiel an @fhoffmann und @httpdigest die hier lieber weniger und dafür hoch exakt schreiben - wie es z.B. auf Stack Overflow auch üblich und notwendig ist! Aber mein innerer Schweinhund lässt mich da schlicht einfach zu faul für sein.) Daher: Auch ein Nachhaken ist herzlich willkommen!

 

[Easyik]

Und nicht vergessen: Du kannst auch hier weiter fragen - niemand ist böse, wenn etwas nicht verstanden wird und Erklärungen, die so auf die Schnelle hin geschrieben werden, sind oft nicht optimal. (Ist ein bekanntes Manko - da müsste ich ggf. noch mehr an mir arbeiten. Da müsste ich mir ein Beispiel an @fhoffmann und @httpdigest die hier lieber weniger und dafür hoch exakt schreiben - wie es z.B. auf Stack Overflow auch üblich und notwendig ist! Aber mein innerer Schweinhund lässt mich da schlicht einfach zu faul für sein.) Daher: Auch ein Nachhaken ist herzlich willkommen!

Also mich Persönlich haben alle Tipps, Ratschläge und Erklärungen weitergebracht.
daher nochmal an alle vielen dank

 

[Easyik]

Gäbe es eine bekannte Möglichkeit den Baum nach folgendem Muster zu befüllen?

                    [0]
            [1]                [2]
            
        [3]    [4]                [5]    [6]
        
    [7]    [8]    [9]    [10] usw.

 

[kneitzel]

Natürlich gibt es da entsprechende Möglichkeiten. Hast Du Dir denn da schon einmal irgendwelche Gedanken gemacht? Siehst Du irgendwelche Kriterien?

Ansonsten schau einfach einmal, ob Dir mathematische Regeln einfallen.

Ein paar Anregungen, die Dir evtl. weiter helfen können:
Wenn Du die Darstellung oben siehst: Das erinnert doch erst einmal direkt an ein Array mit den Elementen [0], [1], [2], ...
Kannst Du da irgendwelche Regeln aufstellen? Also wie kommst Du von einem Element zu dem Vorgänger? Das wäre also: Eine Formel f(x) die für die jeweiligen x dann folgendes ergibt:
1 -> 0
2 -> 0
3 -> 1
4 -> 1
5 -> 2
6 -> 2
7 -> 3
8 -> 3
9 -> 4
10 -> 4
...

Wenn Du das hättest, dann wirst Du es auch umdrehen können um sozusagen die Nachfolger zu bekommen:
0 -> 1, 2
1 -> 3, 4
2 -> 5, 6
3 -> 7, 8
...
Das ist aber nur um das zu verstehen.

Man könnte das f(x) noch so erweitern, dass da zusätzlich noch links bzw. rechts mit ausgeben wird:
1 -> 0 links
2 -> 0 rechts
3 -> 1 links
4 -> 1 rechts
5 -> 2 links
6 -> 2 rechts
7 -> 3 links
8 -> 3 rechts
9 -> 4 links
10 -> 4 rechts
...

Wenn Du das weisst, dann kannst Du die Kette durchgehen: Wenn Du das Element 10 einfügst, dann ist es an der 4 rechts welches an der 1 rechts welches an der 0 links ist. Also kannst Du links gehen, dann rechts um es da dann rechts einzufügen. Das kann man dann abbilden - sieht auf den ersten Blick so aus, als würde da eine Rekursion in Frage kommen.

 

[Easyik]

Natürlich gibt es da entsprechende Möglichkeiten. Hast Du Dir denn da schon einmal irgendwelche Gedanken gemacht? Siehst Du irgendwelche Kriterien?

Ansonsten schau einfach einmal, ob Dir mathematische Regeln einfallen.

Ein paar Anregungen, die Dir evtl. weiter helfen können:
Wenn Du die Darstellung oben siehst: Das erinnert doch erst einmal direkt an ein Array mit den Elementen [0], [1], [2], ...
Kannst Du da irgendwelche Regeln aufstellen? Also wie kommst Du von einem Element zu dem Vorgänger? Das wäre also: Eine Formel f(x) die für die jeweiligen x dann folgendes ergibt:
1 -> 0
2 -> 0
3 -> 1
4 -> 1
5 -> 2
6 -> 2
7 -> 3
8 -> 3
9 -> 4
10 -> 4
...

Wenn Du das hättest, dann wirst Du es auch umdrehen können um sozusagen die Nachfolger zu bekommen:
0 -> 1, 2
1 -> 3, 4
2 -> 5, 6
3 -> 7, 8
...
Das ist aber nur um das zu verstehen.

Man könnte das f(x) noch so erweitern, dass da zusätzlich noch links bzw. rechts mit ausgeben wird:
1 -> 0 links
2 -> 0 rechts
3 -> 1 links
4 -> 1 rechts
5 -> 2 links
6 -> 2 rechts
7 -> 3 links
8 -> 3 rechts
9 -> 4 links
10 -> 4 rechts
...

Wenn Du das weisst, dann kannst Du die Kette durchgehen: Wenn Du das Element 10 einfügst, dann ist es an der 4 rechts welches an der 1 rechts welches an der 0 links ist. Also kannst Du links gehen, dann rechts um es da dann rechts einzufügen. Das kann man dann abbilden - sieht auf den ersten Blick so aus, als würde da eine Rekursion in Frage kommen.

ich hätte an gerade und ungerade gedacht.
Startwert bei 0 und falls die folgende zahl ungerade ist nach links andernfalls nach rechts.

if(wert%2==0){
    links=new Node(wert);
}else{
    rechts=new Node(wert);
}

wie könnte ich den jeden einzelnen Knoten der Breite nach ansprechen ?

 

[kneitzel]

ich hätte an gerade und ungerade gedacht.

Das ist nur zum Teil richtig. Das kommt bezüglich der links / rechts Problematik hin. Aber wie kommt man zu dem übergeordneten Knoten? Oder wie kommt man zu den beiden Nachfolgern wenn Du bei Element x bist?

 

[Easyik]

Das ist nur zum Teil richtig. Das kommt bezüglich der links / rechts Problematik hin. Aber wie kommt man zu dem übergeordneten Knoten? Oder wie kommt man zu den beiden Nachfolgern wenn Du bei Element x bist?

Diese Fragen stelle ich mir gerade auch XD.
ich bin gerade am ende mit meinem Latein

 

[fhoffmann]

ich bin gerade am ende mit meinem Latein

Einfacher machst du es dir, wenn du mit 1 anfängst zu zählen; also:

                     1
        2                         3
  4           5             6           7
8   9      10   11

Dann solltest du die Regel, wie man zu Kind- bzw. Elternknoten kommt, sofort erkennen.

 

[kneitzel]

Ich löse hier jetzt einfach einmal ein bisschen auf, damit Du weiter kommst. Du hast erst einmal richtig festgestellt: Das rechts / links ist schon soweit richtig, wenn es um links/rechts geht. Das wird nachher noch wichtig.

Dann sieht das alles doch ungefähr nach dem Doppelten an:
3 -> 1
5 -> 2
7 -> 3

(Ist halt eine Integer Division - das 0,5 interessiert da nicht.)

Bei den geraden stimmt das aber leider nicht:
4 -> 1 soll es sein aber / 2 wäre 2
6 -> 2 soll es sein aber / 2 wäre 3

Aber oben hatten wir 0,5 zu viel beim Ergebnis und jetzt 1 zu viel - dann lass und einfach einmal erst eins abziehen und dann durch 2 Teilen. Dann wird sich bei den ungeraden nichts ändern und man hat bei den Geraden halt 1 weniger (0,5 abziehen geht ja nicht wirklich):

f(x) = (x-1) / 2

1 -> 0
2 -> 1
3 -> 1

Damit haben wir hier eine erste Vorstellung.

Und wir sehen auch schon: Beim links/rechts haben wir gerade / ungerade betrachtet. Da ist also die frage, ob das letzte Bit 0 oder 1 ist.
Also scheinen da die Bits wichtig zu sein. Dazu malen wir uns wieder alles auf. Da wir immer 1 abziehen müssen bei der Formel, könnte man sich überlegen, ob man einfach schon beim aufschreiben ein -1 nimmt. Dann hat man im Knoten ein -1 stehen. Das ist doof. Also rechnen wir einfach einmal +1. Dann stimmt die Rechnung wieder (Dadurch haben wir beim x ein um 2 höheren Wert. Das Ergebnis ist um 1 höher - und genau das +1 haben wir ja gemacht.

Also haben wir ein Baum:
Oben die 1
dann die 2 und 3 (ein / 2 ergibt die 1!)
dann die 4, 5, 6, 7 (ein / 2 ergibt die 2 und 3)
...

Super!

Aber es geht um die Bits. Also schreib die Zahlen im Binären System auf!
1 => 1
2 => 10
3 => 11
4 => 100
...

Mal Dir diesen Baum einmal auf und schau, wie Du von der Wurzel zu einem Punkt gehen kannst:

Also knoten 1111 -> Du bist 3 mal rechts gegangen
Knoten 1000 -> Du bist 2 mal links gegangen
Knoten 1100 -> links, links, rechts

Das sieht doch gut aus. Du nimmst die Bits also von rechts nach links. Immer das 0er bit entscheidet, ob Du rechts oder links gehen willst.
Danach interessiert das nicht mehr, also das letzte Bit wird gestrichen: Das ist bei binären Zahlen ein / 2

Wir hatten aber dann jetzt immer die erste 1 ignoriert. Wenn Du als Wert nur noch eine 1 hast, dann bist Du am Ziel.

Also n (mit werten ab 1!) nimmst Du.
Am Anfang bist Du an der Wurzel
Wenn n = 1, dann bist Du am Ziel. Hier fügst Du ein.
Sonst: was ist n%2? 0: links, 1: rechts und natürlich wird n = n / 2 gerechnet.
Dann geht es weiter bei "Wenn n = 1"...
==> Schleife oder Rekursion - beides geht.

 

[Easyik]

@fhoffmann @kneitzel vielen dank.

ich setze mich mal dran und versuche das ganze umzusetzen

 

[Blut1Bart]

Ich verstehe einfach nicht, wie sich @Easyik die Ausgabeform vorstellt...

public class BinTree {
    BinTree l;
    BinTree r;
    Object content;

    public String deepToString() {
        BinTree[] a = new BinTree[1000];
        a[0] = this;
        for (int i = 0; i < a.length / 2 - 1; i++) {
            if (a[i] != null) {
                a[2 * i + 1] = a[i].l;
                a[2 * i + 2] = a[i].r;
            }
        }

        StringBuilder b = new StringBuilder();
        b.append(a[0]);
        for (int i = 1; i <= 10; i++) {
            b.append(".".repeat(i * 3));
            for (int j = i; j <= 10; j += i * 2) {
                if (a[j] != null) {
                    b.append(a[j]);
                    b.append(".".repeat(3));
                } else {
                    b.append(".".repeat(4));
                }
            }
            b.append("\n");
        }
        return b.toString();
    }

    @Override
    public String toString() {
        return content.toString();
    }

    public static void main(String[] args) {
        BinTree root = new BinTree();
        root.l = new BinTree();
        root.r = new BinTree();
        root.l.l = new BinTree();
        root.l.r = new BinTree();
        root.l.r.r = new BinTree();
        root.l.l.l = new BinTree();
        root.content = "0";
        root.l.content = "1";
        root.r.content = "2";
        root.l.l.content = "3";
        root.l.r.content = "4";
        root.l.l.l.content = "7";
        root.l.r.r.content = "10";
        System.out.println(root.deepToString());
    }
}

0...1...3.......7.......
......2.......10...
.........3.......
............4...
...................
......................
.....................7...
............................
...............................
..............................10...

das macht für mich bis jetzt nur bedingt sinn...

 

[Easyik]

[root]    links    links.links        links.links.links .....
                                links.links.rechts
                links.rechts    links.rechts.links
                                links.rechts.rechts
und das selbe nochmal für den Rechten zwei

das war gewollt und auch umgesetzt ^^

falls du nach dem Sinn dahinter fragst, da gibt es keinen jedenfalls keinen den ich verfolge

 

[Blut1Bart]

das war gewollt und auch umgesetzt

oh, na dann ist die Aufgabe ja schon erledigt

 

[Easyik]

oh, na dann ist die Aufgabe ja schon erledigt

nur zum teil, währenddessen hat sich ein grober Fehler innerhalb der insert-Methode bemerkbar gemacht. habe jetzt zwar einen guten Ansatz aber für heute reicht es auch langsam.

wenn ich es morgen fertig kriege würde ich auch die Lösung hier reinsetzen, falls dies erlaubt und gewünscht ist

 

[Easyik]

so nachdem ich mich dran gesetzt habe die Tipps umzusetzen ist bei mir dieser Code entstanden :

public int korrekturDerReihenfolge(int n){
    if(n%2==0){
        n=n/2;
    }else{
    n=(n-1)/2;
    }
    return n;
}

public void insert(String eingabe,int status){
    int n=status;
    if(links==null&& status%2==0){
        links=new Knoten(eingabe,status);
    }else if(rechts==null && status%2 !=0){
        rechts=new Knoten(eingabe,status);
    }else{

    korrekturDerReihenfolge(n);
    if(n==links.status){
        links.insert(eingabe, status);

    }else if(n==rechts.status){
        rechts.insert(eingabe, status);
    }
}
}

jedoch hat sich da ein Fehler eingeschlichen, und ich komme nicht weiter als zu den ersten Child-Elementen

könnte jemand einen blick darauf werfen und mich auf den Fehler hinweisen ?

 

[Easyik]

OK habe den Fehler gesehen und behoben.
ich rufe Zwar die Funktion korrektur... auf aber speichere die nicht zwischen XD