DeleteNode-Funktionalität in einem AVL-Tree

Zrebna

Zrebna

Bekanntes Mitglied
Hi!

Ich habe Probleme in einem AVL-Tree Nodes zu löschen.
Die zwei ersten Schritte müssten ja so sein, wie in einem Binärbaum, d.h.:
1.) Man findet den Knoten mit dem Wert, den man löschen will.
2.) Man löscht den Knoten auf eine Weise, die davon abhängt, ob Fall 1 (kein NF), Fall 2 (nur ein NF - einfach "umhängen) oder Fall 3 (2 NF) zutrifft.

Nun müsste man aber an dieser Stelle prüfen, ob die AVL-Eigenschaft noch gegeben ist und falls nicht, dann nnotfall rotieren.
Ich weiß nicht an welcher Stelle ich es prüfen soll.
Wenn man einen Knoten löscht, dann kann ja nun der Teilbaum auf der anderen Seite zu hoch sein (Höhen_Betrag > 1).
Um die andere Seite aber bzgl. ihrer AVL-Eigenschaft zu prüfen, bräuchte ich ja den Vorgänger des gelöschten Knotens, weil dieser ja die Wurzel von beiden Seiten (Teilbäumen) darstellt?
Jedoch denke ich nicht, dass unser Prof sich das so gedacht hat und daher ist meine Idee wohl falsch.
Ich denke ich poste mal den gesamten Code und danach nochmal nur separat die Delete-Funktion, zur besseren Übersicht.
Die AVL-Eigenschaft wird bei mir mittels den Funktionen "checkRotationLeft" oder "checkRotsationRight" überprüft.
Falls ein Teilbaum zu hoch ist, dann wird in einer dieser Funktionen auch die benötigte Rotations-Operation aufgerufen (entweder Einfach-oder Doppelrotation).
Der Code ist an meine Vorlesung und Übung angelegt und soll bzgl. der Implementation auch weitgehend so wenig, wie möglich verändert werden (gibt ja im Internet viele diverse Möglichkeiten zu finden...).
Ich will nur verstehen, wie und wo ich nach dem Löschen eines Knotens die AVL-Eigenschaft prüfen und ggf. wiederherstellen muss?
Für Hilfe bin ich wie immer dankbar:)

Hier dann erstmal der gesamte Code:
Java:
public class Element {
    public int height;
    public int value;

    // references
    Element right;
    Element left;
}

class AVLTree {
    Element root;

    public AVLTree() {
        root = null;
    }

    public static void main(String[] args) {
        AVLTree tree = new AVLTree();

        int[] arr = {15, 5, 3, 20, 14, 16, 25, 24, 27, 18, 19};

        for(int i = 0; i < arr.length; i++) {
            tree.insert(arr[i]);
        }
        System.out.println("current tree:");
        tree.print();

        tree.delete(18);
        System.out.println("tree after deleting the value '18'");
        tree.print();
    }

    //------------------ private logic----------------------------------------------
    private int max(int a, int b) {
        if(a < b)
            return b;
        else
            return  a;
    }

    private int getHeight(Element element) {
        if(element == null)
            return -1;
        else
            return element.height;
    }

    private void updateHeight(Element element) {
        element.height = 1 + max(getHeight(element.left), getHeight(element.right));
    }

    private Element rotateLeft(Element a) {
        Element b = a.right; // future root

        a.right = b.left;  // linker Nachfolger von b, wird zum rechtem Nachfolger von a (vorherige root)
        b.left = a;     // a kommt links zu b nach unten

        a = b; // b wird zu neuen root

        updateHeight(a.left);
        updateHeight(a);

        return a;
    }

    private Element rotateRight(Element a) {
        Element b = a.left;

        a.left = b.right; // b.right wird zu a.left
        b.right = a;
        a = b;

        updateHeight(a.right);
        updateHeight(a);

        return a;
    }

    private Element doubleRotationLeft(Element a) {
        a = rotateRight(a.right);
        a = rotateLeft(a);

        return a;
    }

    private Element doubleRotationRight(Element a) {
        a = rotateLeft(a.left);
        a = rotateRight(a);

        return a;
    }

    private Element checkRotationRight(Element element) {
        if(element != null) {
            if(element.left != null) {
                if(getHeight(element.left) - getHeight(element.right) == 2) {
                    if(getHeight(element.left.right) > getHeight(element.left.left)) {
                        element = doubleRotationRight(element); // da innerer Teilbaum zu hcch ist
                    } else {
                        element = rotateRight(element); // äußerer Teilbaum zu hoch -> muss einfach-rotiert werden
                    }
                } else {
                    updateHeight(element);
                }
            } else {
                updateHeight(element);
            }
        }
        return  element;
    }

    private Element checkRotationLeft(Element element) {
        if(element != null) {
            if(element.right != null) {
                if(getHeight(element.right) - getHeight(element.left) == 2) {
                    if(getHeight(element.right.left) > getHeight(element.right.right)) {
                        element = doubleRotationLeft(element); // da innerer Teilbaum zu hcch ist
                    } else {
                        element = rotateLeft(element); // äußerer Teilbaum zu hoch -> muss einfach-rotiert werden
                    }
                } else {
                    updateHeight(element);
                }
            } else {
                updateHeight(element);
            }
        }
        return  element;
    }

    private Element insert(Element element, int value) {
        if(element == null) {
            element = new Element();
            element.height = 0;
            element.value = value;
            element.left = null;
            element.right = null;
            return element;
        } else {
            if(value <= element.value) {
                element.left = insert(element.left, value);
                element = checkRotationRight(element);
            } else {
                element.right = insert(element.right, value);
                element = checkRotationLeft(element);
            }
        }
        return element;
    }

    /**
     * Step 1: find node with value to be deleted
     * Step 2: delete node (3 cases and algo same as in binary linked search tree)
     * step 3: verify/recreate avl-property
     *           -> examine from bottom to top
     *
     * @param element -> current one
     * @param value to be deleted
     * @return
     */
    private Element delete(Element element, int value) {
        if(element.value == value) {
            // Fall 1: kein NF
            if(element.left == null && element.right == null) {
                element = null;
                element = checkRotationRight(element);
                element = checkRotationLeft(element);

                return element;
            }
            // Fall 2: Nur genau 1 NF
            if(element.left == null) {
                element = element.right;
                element = checkRotationRight(element);

                return  element;
            }
            if(element.right == null) {
                element = element.left;
                element = checkRotationLeft(element);
                return element;
            }
            // Fall 3: 2 NF -> find direct inorder-successor-value
            int smallestVal = findMinVal(element.right);
            element.value = smallestVal;
            // delete inOrder-Node from right sub-tree
            element.right = delete(element.right, smallestVal);

            element = checkRotationRight(element);
            element = checkRotationLeft(element);

            return element;
                   // search code
        } else {
            if(value < element.value) {
                element.left = delete(element.left, value);
                return element;
            } else {
                element.right = delete(element.right, value);
                return element;
            }
        }
    }

    private int findMinVal(Element current) {
        if(current.left == null) {
            return current.value;
        } else {
            return findMinVal(current.left);
        }
    }

    private void print(Element root) { // in order: left - rootOutput - right
        if(root != null) {
            System.out.print("(");
            print(root.left);
            System.out.print("," + root.value + ",");
            print(root.right);
            System.out.print(")");
        } else {
            System.out.print("n");
        }
    }

    //------------------ public logic----------------------------------------------
    public Element insert(int value) {
        root = insert(root, value);
        return root;
    }

    public Element delete(int value) {
       root = delete(root, value);
       return root;
    }

    public void print() {
        print(root);
        System.out.println();
    }
}


Nur Codesnippet von der Delete-Funktion:
Java:
 /**
     * Step 1: find node with value to be deleted
     * Step 2: delete node (3 cases and algo same as in binary linked search tree)
     * step 3: verify/recreate avl-property
     *           -> examine from bottom to top
     *
     * @param element -> current one
     * @param value to be deleted
     * @return
     */
    private Element delete(Element element, int value) {
        if(element.value == value) {
            // Fall 1: kein NF
            if(element.left == null && element.right == null) {
                element = null;
                element = checkRotationRight(element);
                element = checkRotationLeft(element);

                return element;
            }
            // Fall 2: Nur genau 1 NF
            if(element.left == null) {
                element = element.right;
                element = checkRotationRight(element);

                return  element;
            }
            if(element.right == null) {
                element = element.left;
                element = checkRotationLeft(element);
                return element;
            }
            // Fall 3: 2 NF -> find direct inorder-successor-value
            int smallestVal = findMinVal(element.right);
            element.value = smallestVal;
            // delete inOrder-Node from right sub-tree
            element.right = delete(element.right, smallestVal);

            element = checkRotationRight(element);
            element = checkRotationLeft(element);

            return element;
                   // search code
        } else {
            if(value < element.value) {
                element.left = delete(element.left, value);
                return element;
            } else {
                element.right = delete(element.right, value);
                return element;
            }
        }
    }

edit:
Diesen Hinweis habe ich noch in meinen Vorlesungsunterlagen zum 3tem Schritt (also nachdem der Knoten gelöscht wurde) gefunden:
" Wiederherstellung der AVL Eigenschaft:
Such -/Löschpfad wird von „unten nach oben“ durchlaufen
AVL Eigenschaft prüfen und ggf. durch Rotationen wiederherstellen "


Leider bleiben meine Fragen erhalten:(
Ich weiß z.B. nicht wie ich den Baum von unten nach oben durchlaufen soll, wenn wir in dieser Implementierung keine Referenzen auf die parentNodes haben. Auch wüßte ich nicht wie und an welchen Stellen genau die AVL-Eigenschaft geprüft werden soll, d.h.
wohl die 'checkRotaion/Left/Right'-Funktion aufgerufen werden soll.
 
Zuletzt bearbeitet:
mihe7

mihe7

Top Contributor
Dein delete ist rekursiv, d. h. Du hast ganz automatisch zunächst einen rekursiven Abstieg - bis zur Abbruchbedingung - und anschließend wieder einen Aufstieg :)
 
Zrebna

Zrebna

Bekanntes Mitglied
Dein delete ist rekursiv, d. h. Du hast ganz automatisch zunächst einen rekursiven Abstieg - bis zur Abbruchbedingung - und anschließend wieder einen Aufstieg :)
Ja, stimmt vollkommen richtig^^
Ok, das ist ja schon mal gut - in dem Fall würde ich meine Delete-Funktion in den Zeile 34 und 38 folgendermaßen modifizieren:
Java:
private Element delete(Element element, int value) {
        if(element.value == value) {
            // Fall 1: kein NF
            if(element.left == null && element.right == null) {
                element = null;
                element = checkRotationRight(element);
                element = checkRotationLeft(element);

                return element;
            }
            // Fall 2: Nur genau 1 NF
            if(element.left == null) {
                element = element.right;
                element = checkRotationRight(element);

                return  element;
            }
            if(element.right == null) {
                element = element.left;
                element = checkRotationLeft(element);
                return element;
            }
            // Fall 3: 2 NF -> find direct inorder-successor-value
            int smallestVal = findMinVal(element.right);
            element.value = smallestVal;
            // delete inOrder-Node from right sub-tree
            element.right = delete(element.right, smallestVal);

            return element;
                   // search code
        } else {
            if(value < element.value) {
                element.left = delete(element.left, value);
                element = checkRotationLeft(element);
                return element;
            } else {
                element.right = delete(element.right, value);
                element = checkRotationRight(element);
                return element;
            }
        }
    }

Sprich ich checke dort jeden Knoten auf dem Weg zurück nach oben, nachdem Rekursionsende erreicht worden ist, auf die AVL-Eigenschaft,
aber: diesmal synchron (im Gegensatz zur insert()), weil ja der entgegensetzte Teilbaum nach Entfernen eines Knotens nun zu hoch sein könnte.

Passt meine Änderung soweit oder ist der Code weiterhin fehlerhaft?
 
mihe7

mihe7

Top Contributor
Zeilen 6, 7, 14 und 20 geben in meinen Augen keinen Sinn: wenn die AVL-Eigenschaft vor dem Entfernen gegolten hat und der Knoten höchstens einen Kindknoten besitzt, ist die Höhe des anderen Teilbaums 0 und somit kann die Höhe des anderen Teilbaums höchstens 1 sein. Nach dem Entfernen haben beide Teilbäume die Höhe 0. Da gibt es nichts zu rotieren. Problematisch kann es nur werden, wenn ein rekursiver Aufruf erfolgt, also nach den Zeilen 27, 33 und 37. Wenn ich mich gerade nicht vertue :)
 
Zrebna

Zrebna

Bekanntes Mitglied
Zeilen 6, 7, 14 und 20 geben in meinen Augen keinen Sinn: wenn die AVL-Eigenschaft vor dem Entfernen gegolten hat und der Knoten höchstens einen Kindknoten besitzt, ist die Höhe des anderen Teilbaums 0 und somit kann die Höhe des anderen Teilbaums höchstens 1 sein. Nach dem Entfernen haben beide Teilbäume die Höhe 0. Da gibt es nichts zu rotieren. Problematisch kann es nur werden, wenn ein rekursiver Aufruf erfolgt, also nach den Zeilen 27, 33 und 37. Wenn ich mich gerade nicht vertue :)
Ah, Zeile 6, 7, 14 und 20 habe ich vorher vergessen zu entfernen - dort kann es ja noch nicht zu Problemen kommen.

Aber die Stelle nach Zeile (vorher) 27 hätte ich glatt übersehen - dort wird ja Löschfunktion ebenfalls aufgerufen...
Neuer Code sähe so aus:

Java:
 private Element delete(Element element, int value) {
        if(element.value == value) {
            // Fall 1: kein NF
            if(element.left == null && element.right == null) {
                element = null;
                return element;
            }
            // Fall 2: Nur genau 1 NF
            if(element.left == null) {
                element = element.right;
                return  element;
            }
            if(element.right == null) {
                element = element.left;
                return element;
            }
            // Fall 3: 2 NF -> find direct inorder-successor-value
            int smallestVal = findMinVal(element.right);
            element.value = smallestVal;
            // delete inOrder-Node from right sub-tree
            element.right = delete(element.right, smallestVal);
            // check avl property after recursive call of delete-functionality
            element.right = checkRotationLeft(element.right);

            return element;
                   // search code
        } else {
            if(value < element.value) {
                element.left = delete(element.left, value);
                element = checkRotationLeft(element); // opposed subtree might be now to high and thus must be potentially left-rotated
                return element;
            } else {
                element.right = delete(element.right, value);
                element = checkRotationRight(element);
                return element;
            }
        }
    }

In Zeile 23 bin ich mir aber nicht sicher.
Wir löschen ja von dem Teil-Wurzel-Knoten element.right den linkesten Wert.
Dann kann ja nur der rechte Ast zu hoch werden -> also Linksrotation?
Diese am element.right (von dem ja ursprünglich die rekursiven Aufrufe gestartet haben) oder vom darüberliegendem Knoten "element"?
Na ja, ich versuch das nun einfach mal und guck mal...ggf. melde ich mich später nochmal - jedenfalls vielen Dank soweit:)
 
Zrebna

Zrebna

Bekanntes Mitglied
Update:
Denk-/Vorstellungsfehler vorher - Zeile 23 muss sein:
Java:
element = checkRotationRight(element);

Denn wir haben ja auf der rechten Seite bzw. im rechtem Teilbaum des gegebenen "Grund"-Knotens einen Knoten entfernt (und zwar dort den, der den kleinsten Wert hatte).
Foglich kann es nun sein, dass der linke Teilbaum des "Grund"-Knotens zu hoch ist und daher eben dort rechts rotiert werden muss,
und zwar um den "Grund"-Knoten.

Code macht nun zumindest, was er soll^^
 
Ähnliche Java Themen
  Titel Forum Antworten Datum
DStrohma 2D-Grafik Verbesserungen an Hot Corner Funktionalität? Allgemeine Java-Themen 6
P Applet Funktionalität überwachen Allgemeine Java-Themen 3
Kingamadeus2000 Alle mehrfach vorkommenden Buchstaben rekursiv aus einem String entfernen. Allgemeine Java-Themen 6
F Junit Test + Cucumber - JSON auslesen und in einem weiteren Schritt nutzen Allgemeine Java-Themen 0
pkm Warnungen in einem Drools-Projekt unterdrücken? Allgemeine Java-Themen 1
D Arbeiten mit einem Bitarray Allgemeine Java-Themen 13
D Union in einem Struct in JNA Allgemeine Java-Themen 5
N Apache POI/ neue Reihe in Excel mit einem Button Allgemeine Java-Themen 2
E Datentypen Wie kann ich die Längen der unterschiedlichen Ebenen aus einem Objekt lesen von dem ich weiß, dass es ein mehrdimensionaler Array ist? Allgemeine Java-Themen 3
R Zoom In einem grid Allgemeine Java-Themen 0
M java.io.EOFException bei einem DataoutputStream ?! Allgemeine Java-Themen 2
D Kgv aller Paare aus einem Array mit n integer berechnen Allgemeine Java-Themen 5
D Verkauf von einem Programm welches ich in Java geschrieben habe Allgemeine Java-Themen 4
M Fahrtsimulation von einem Zug Allgemeine Java-Themen 0
A 2D-Grafik Einfachster Ansatz, um sich wiederholende Figur in einem 2D-Image zu erkennen Allgemeine Java-Themen 1
P einen public <Optinal String> in einer anderen Klasse mit einem Int vergleichen Allgemeine Java-Themen 2
Drachenbauer Wie kann ich das Wort "concrete" in einem String durch ein anderes Wort ersetzen lassen? Allgemeine Java-Themen 5
J Suchen von einer Scannereingabe in einem HashSet Allgemeine Java-Themen 1
L Input/Output Kassenzettel lesen aus einem Bild Allgemeine Java-Themen 2
G JTextField Inhalt in einem Long einfügen Allgemeine Java-Themen 2
M Bei String.format ein Komma statt einem Punkt ausgeben lassen Allgemeine Java-Themen 1
K Bild in einem anderen Bild suchen Allgemeine Java-Themen 12
B Problem zu einem Java Projekt Allgemeine Java-Themen 6
ralfb1105 Starten Java App(s) (.jar) aus einem Java Programm Allgemeine Java-Themen 18
B Suche nach einem Testprogramm für meine BA Allgemeine Java-Themen 0
B Maven Zugriff auf files aus einem kompilierten jar Allgemeine Java-Themen 15
D Warum kann ich eine (deflaut) Klasse aus einer Libary in einem anderen Projekt benutzen? Allgemeine Java-Themen 3
R Farbe zu einem Eckpunkt generieren Allgemeine Java-Themen 0
C Logfile upload zu einem externen filezilla sftp server Allgemeine Java-Themen 6
X Punkte in einem Feld bestimmen Allgemeine Java-Themen 22
H Laden einer (Resourcendatei) aus einem Jar-File Allgemeine Java-Themen 17
J In einem Set doppelte Elemente erzeugen Allgemeine Java-Themen 4
D HTTP Aufruf einer Methode aus einem Servlet heraus Allgemeine Java-Themen 0
S Kann man mit Java auf einem lokalen PC/Mac Benutzergruppen auslesen und Rechte ändern? Allgemeine Java-Themen 11
S Algorithmus welcher True-Werte in einem Array findet und auswertet. Allgemeine Java-Themen 5
R Index in einem Array löschen Allgemeine Java-Themen 10
R Index in einem Array löschen Allgemeine Java-Themen 2
4 Swing Durch klicken auf Button Labels einem Panel hinzufügen Allgemeine Java-Themen 4
The Pi Wie oft wird ein Buchstabe in einem Wort wiederholt? Allgemeine Java-Themen 16
D Kopieren von Dateien aus einem Ordner in einen anderen Allgemeine Java-Themen 6
K Classpath Alle Classen aus einem Package lesen Allgemeine Java-Themen 7
K Auf einer Website nach einem String suchen Allgemeine Java-Themen 5
P Zwei Applikationen mit einem Job Allgemeine Java-Themen 0
Sin137 OOP Auf JPanel zugreifen, das einem JTabbePane hinzugefügt worden ist Allgemeine Java-Themen 10
E Die if-Anweisung in einer Java Bean bzw. in einem Servlet? Allgemeine Java-Themen 8
0 Methoden Aus einem Event, wo ich weiß, dass es ausgeführt werden wird, eine Get-Methode basteln Allgemeine Java-Themen 8
F Wie kann ich auf einem System prüfen, ob eine lib verfügbar ist? Allgemeine Java-Themen 2
M Ein Programm das nur von einem bestimmten Programm geöffnet werden kann Allgemeine Java-Themen 7
H Klammerberechnungen bei einem Taschenrechner Allgemeine Java-Themen 2
S Kann man mit einem GeneralPath.curveTo ein GeneralPath.quadTo ersetzen..? Allgemeine Java-Themen 2
Seikuassi Alle Escape-Sequenzen in einem String ersetzen Allgemeine Java-Themen 4
S Rekursive Suche in einem Netz Allgemeine Java-Themen 5
A Input/Output Liste der Dateien in einem Ordner in einer Jar Datei erhalten Allgemeine Java-Themen 11
T Schlüsselworte mehrere public-Klassen in einem Paket Allgemeine Java-Themen 7
M Zeilen zu einem DefaultTableModel hinzufügen Allgemeine Java-Themen 1
M Dateien aus einem Verzeichnis auf einem Server auflisten Allgemeine Java-Themen 5
Thallius PDF von einem BufferedImage erstellen Allgemeine Java-Themen 1
M Abonnentenzahl, Aufrufe, etc. von einem YouTube-Kanal anzeigen Allgemeine Java-Themen 7
B Fehler bei einem Programm Allgemeine Java-Themen 10
E am häufigsten vorkommenden Farben aus einem Bild Allgemeine Java-Themen 5
C Threads Variablen in einem Thread Aktualisieren Allgemeine Java-Themen 17
F Punkte in einem Bild finden Allgemeine Java-Themen 10
M Eclipse Eine xhtml aus einem JSF Projekt starten Allgemeine Java-Themen 2
M String an einem abschnitt ändern Allgemeine Java-Themen 14
I Zu zweit an einem Projekt? Allgemeine Java-Themen 1
S Methoden Stunden seit einem bestimmten Zeitpunkt Allgemeine Java-Themen 3
D Problem mit Login in einem Dynamischen Webprojekt Allgemeine Java-Themen 1
D Grafisches Frontend zu einem Java Prozess erstellen Allgemeine Java-Themen 0
S Panel zur Dateiendarstellung wie in einem Explorer Allgemeine Java-Themen 12
K Code zu einem Projekt entschluesseln Allgemeine Java-Themen 15
J Ist eine Instanz von einem bestimmten Object Typ? Allgemeine Java-Themen 6
M Lichteffekte in einem Java-Spiel Allgemeine Java-Themen 4
A Auswahl eines JEditorPane das Sich in einem JScrollPanel Befindet Allgemeine Java-Themen 2
S Android: Verlinkung in einem TextView Allgemeine Java-Themen 3
Minonos Einem Programm Zugriff auf bestimmte Ordner geben Allgemeine Java-Themen 5
F Funktion nur in einem Zeitraum Allgemeine Java-Themen 5
L Klassen Polymorphie:2 Attribute gleichen Namens in einem Objekt Allgemeine Java-Themen 6
J Datentypen Verständnisprobleme bei einem Quelltext Allgemeine Java-Themen 32
I Sound abspielen aus einem Sample-Array Allgemeine Java-Themen 2
S Entfernen von allen Nicht-Buchstaben chars aus einem String ohne Regex..? Allgemeine Java-Themen 10
D IP / Domain in einem String erkennen Allgemeine Java-Themen 2
SexyPenny90 Spalte einer Exceldatei in einem String speichern Allgemeine Java-Themen 11
K Quadrat in einem Bild erkennen Allgemeine Java-Themen 33
P ganze Zeilen in einem File mit .replace() ändern. Allgemeine Java-Themen 10
P Aus einem File Zeilen auslesen. Allgemeine Java-Themen 15
M Ein bestimmtes Wort in einem Text zählen (String in String) Allgemeine Java-Themen 9
A runnable jar läuft mur auf einem pc1 und nicht auf pc2 Allgemeine Java-Themen 6
P Einzelnen String aus einem String Array rausholen Allgemeine Java-Themen 3
R Bewerbung in einem Entwicklerstudio Allgemeine Java-Themen 28
F Groovy Erkennen geometrischer Formen in einem Kantenbild Allgemeine Java-Themen 4
P Eclipse Gemeinsam mit NetBeans an einem Projekt arbeiten? Allgemeine Java-Themen 3
R Änderungen in einem Verzeichnis beobachten - Windows Allgemeine Java-Themen 3
R In einem Byte-Array nach einer gewissen Zahlenfolge suchen Allgemeine Java-Themen 7
F Herausfinden ob nur 1 oder 0 in einem String ist. Allgemeine Java-Themen 4
kodela aktiver Link in einem Dialog Allgemeine Java-Themen 14
C aus einem String einzelne Hex Werte lesen Allgemeine Java-Themen 7
T Mit Java auf Dateien zugreifen die auf einem Server liegen Allgemeine Java-Themen 5
L Methoden Spieler zufällig einem Team zuweisen Allgemeine Java-Themen 6
S Knoten zählen in einem Binärbaum Allgemeine Java-Themen 2
C Mit Java in einem anderes Programm eingreifen Allgemeine Java-Themen 21

Ähnliche Java Themen

Anzeige

Neue Themen


Oben