{"id":30530,"date":"2019-10-31T21:36:01","date_gmt":"2019-10-31T18:36:01","guid":{"rendered":"https:\/\/prohoster.info\/blog\/binary-tree-ili-kak-prigotovit-binarnoe-derevo-poiska\/"},"modified":"2019-10-31T21:36:01","modified_gmt":"2019-10-31T18:36:01","slug":"binary-tree-ili-kak-prigotovit-binarnoe-derevo-poiska","status":"publish","type":"post","link":"https:\/\/prohoster.info\/de\/blog\/administrirovanie\/binary-tree-ili-kak-prigotovit-binarnoe-derevo-poiska","title":{"rendered":"Bin\u00e4rbaum oder wie man einen Bin\u00e4rsuchbaum erstellt","gt_translate_keys":[{"key":"rendered","format":"text"}]},"content":{"rendered":"

Einleitung<\/h2>\n

\nDieser Artikel widmet sich Bin\u00e4rsuchb\u00e4umen. K\u00fcrzlich habe ich einen Artikel \u00fcber Datenkompression mit dem Huffman-Verfahren geschrieben.<\/a><\/noindex> Dabei habe ich nicht viel Aufmerksamkeit auf Bin\u00e4rb\u00e4ume gelegt, da die Methoden f\u00fcr Suche, Einf\u00fcgen und L\u00f6schen nicht relevant waren. Jetzt habe ich beschlossen, einen Artikel genau \u00fcber B\u00e4ume zu schreiben. Fangen wir an. <\/p>\n

Ein Baum ist eine Datenstruktur, die aus Knoten besteht, die durch Kanten verbunden sind. Man kann sagen, dass ein Baum eine spezielle Form eines Graphen ist. Hier ist ein Beispiel f\u00fcr einen Baum: <\/p>\n

\"Bin\u00e4rbaum
\n
\nDas ist kein Bin\u00e4rsuchbaum! Alle Details im weiterhin genannten Text!
\n<\/a><\/noindex><\/p>\n

Terminologie<\/h2>\n

<\/p>\n

Wurzel<\/h4>\n

\nDie Wurzel des Baums<\/i> ist der oberste Knoten. Im Beispiel ist das der Knoten A. Im Baum kann es von der Wurzel zu jedem anderen Knoten nur einen einzigen Pfad geben! Tats\u00e4chlich kann jeder Knoten als Wurzel des entsprechenden Teilbaums betrachtet werden.<\/p>\n

Eltern\/Kinder<\/h4>\n

\nAlle Knoten, au\u00dfer der Wurzel, haben genau eine Kante, die nach oben zu einem anderen Knoten f\u00fchrt. Der Knoten, der sich \u00fcber dem aktuellen befindet, wird als Elternteil<\/i> dieses Knotens bezeichnet. Der Knoten, der sich unter dem aktuellen befindet und mit ihm verbunden ist, wird als Kind<\/i> dieser Knoten. Lassen Sie uns ein Beispiel nehmen. Nehmen wir Knoten B, dann wird sein Elternteil Knoten A sein, und die Nachkommen sind die Knoten D, E und F.<\/p>\n

Blatt<\/h4>\n

\nEin Knoten, der keine Nachkommen hat, wird als Blatt des Baumes bezeichnet. In diesem Beispiel sind die Bl\u00e4tter die Knoten D, E, F, G, I, J, K.<\/p>\n

Das ist die grundlegende Terminologie. Weitere Konzepte werden sp\u00e4ter behandelt. Ein bin\u00e4rer Baum ist ein Baum, in dem jeder Knoten nicht mehr als zwei Nachkommen hat. Wie Sie sich denken k\u00f6nnen, ist der Baum aus dem Beispiel kein bin\u00e4rer Baum, da die Knoten B und H mehr als zwei Nachkommen haben. Hier ist ein Beispiel f\u00fcr einen bin\u00e4ren Baum:<\/p>\n

\"Bin\u00e4rbaum
\n
\nIn den Knoten des Baumes kann jede Art von Informationen gespeichert werden. Ein bin\u00e4rer Suchbaum ist ein bin\u00e4rer Baum, der folgende Eigenschaften hat:<\/p>\n

    \n
  1. Beide Teilb\u00e4ume \u2013 der linke und der rechte \u2013 sind bin\u00e4re Suchb\u00e4ume.<\/li>\n
  2. F\u00fcr alle Knoten des linken Teilbaums eines beliebigen Knotens X sind die Werte der Schl\u00fcsseldaten kleiner als der Wert des Schl\u00fcssels selbst von Knoten X.<\/li>\n
  3. F\u00fcr alle Knoten des rechten Teilbaums eines beliebigen Knotens X sind die Werte der Schl\u00fcsseldaten gr\u00f6\u00dfer oder gleich dem Wert des Schl\u00fcssels selbst von Knoten X. <\/li>\n<\/ol>\n

    Der Schl\u00fcssel<\/i> \u2014 eine Eigenschaft des Knotens (zum Beispiel eine Zahl). Der Schl\u00fcssel wird ben\u00f6tigt, um das entsprechende Element des Baumes zu finden. Beispiel eines bin\u00e4ren Suchbaums:<\/p>\n

    \"Bin\u00e4rbaum
    \n<\/p>\n

    Darstellung des Baumes<\/h2>\n

    \nIm Verlauf werde ich einige (m\u00f6glicherweise unvollst\u00e4ndige) Code-Schnipsel anf\u00fchren, um Ihr Verst\u00e4ndnis zu verbessern. Den vollst\u00e4ndigen Code finden Sie am Ende des Artikels. <\/p>\n

    Ein Baum besteht aus Knoten. Die Struktur eines Knotens:<\/p>\n

    public class Node<T> {\n    private T data;\n    private int key;\n    private Node<T> leftChild;\n    private Node<T> rightChild;\n\n    public Node(T data, int key) {\n        this.data = data;\n        this.key = key;\n    }\n    public Node<T> getLeftChild() {\n        return leftChild;\n    }\n\n    public Node<T> getRightChild() {\n        return rightChild;\n    }\n\/\/...weitere Methoden des Knotens\n}\n<\/code><\/pre>\n
    \nJeder Knoten hat zwei Nachkommen (es ist durchaus m\u00f6glich, dass die Nachkommen leftChild und\/oder rightChild den Wert null enthalten). Sie haben wahrscheinlich verstanden, dass in diesem Fall die Zahl data \u2014 die Daten sind, die im Knoten gespeichert sind; key \u2014 der Schl\u00fcssel des Knotens.<\/p>\n
    Jetzt, wo wir den Knoten behandelt haben, sprechen wir \u00fcber aktuelle Probleme im Zusammenhang mit B\u00e4umen. Hier und im Folgenden beziehe ich mich auf den Begriff des bin\u00e4ren Suchbaums. Die Struktur eines bin\u00e4ren Baums:<\/p>\n
    public class BinaryTree<T> {\n     private Node<T> root;\n\n    \/\/ Methoden des Baumes\n}\n<\/code><\/pre>\n
    Als Klassenfeld ben\u00f6tigen wir nur die Wurzel des Baumes, da wir \u00fcber die Methoden getLeftChild() und getRightChild() von der Wurzel zu jedem Knoten im Baum gelangen k\u00f6nnen.<\/p>\n
    Algorithmen im Baum<\/h2>\n
    <\/p>\n
    \u041f\u043e\u0438\u0441\u043a<\/h3>\n
    \nAngenommen, Sie haben einen aufgebauten Baum. Wie finden Sie das Element mit dem Schl\u00fcssel key? Sie m\u00fcssen sich schrittweise von der Wurzel nach unten bewegen und den Wert key mit dem Schl\u00fcssel des aktuellen Knotens vergleichen: Ist key kleiner als der Schl\u00fcssel des aktuellen Knotens, wechseln Sie zum linken Kind dieses Knotens; ist er gr\u00f6\u00dfer, zum rechten; wenn die Schl\u00fcssel gleich sind, wurde der gesuchte Knoten gefunden! Der entsprechende Code lautet:<\/p>\n
    public Node<T> find(int key) {\n    Node<T> current = root;\n    while (current.getKey() != key) {\n        if (key < current.getKey())\n            current = current.getLeftChild();\n        else\n            current = current.getRightChild();\n        if (current == null)\n            return null;\n    }\n    return current;\n}\n<\/code><\/pre>\n
    \nWenn current null wird, bedeutet das, dass die Durchsuchung das Ende des Baumes erreicht hat (auf konzeptioneller Ebene befinden Sie sich an einem nicht existierenden Ort im Baum \u2013 einem Nachkommen des Blattes).<\/p>\n
    Betrachten wir die Effizienz des Suchalgorithmus in einem balancierten Baum (einem Baum, in dem die Knoten mehr oder weniger gleichm\u00e4\u00dfig verteilt sind). Die Sucheffizienz betr\u00e4gt dann O(log(n)), wobei der Logarithmus zur Basis 2 verwendet wird. Sehen Sie: Wenn ein balancierter Baum n Elemente hat, bedeutet das, dass es log(n) Ebenen im Baum gibt, die zur Basis 2 berechnet werden. Bei der Suche steigen Sie in jedem Schritt der Schleife eine Ebene hinunter.<\/p>\n
    Einf\u00fcgen<\/h3>\n
    \nWenn Sie das Prinzip der Suche verstanden haben, wird es Ihnen leichtfallen, das Einf\u00fcgen zu verstehen. Sie m\u00fcssen einfach zum Blatt des Baumes hinuntersteigen (den Regeln des Abstiegs folgen, die in der Suche beschrieben sind) und dort Nachkommen werden \u2013 entweder links oder rechts, je nach Schl\u00fcssel. Implementierung:<\/p>\n
       public void insert(T insertData, int key) {\n        Node current = root;\n        Node parent;\n        Node newNode = new Node(insertData, key);\n        if (root == null)\n            root = newNode;\n        else {\n            while (true) {\n                parent = current;\n                if (key < current.getKey()) {\n                    current = current.getLeftChild();\n                    if (current == null) {\n                         parent.setLeftChild(newNode);\n                         return;\n                    }\n                }\n                else {\n                    current = current.getRightChild();\n                    if (current == null) {\n                        parent.setRightChild(newNode);\n                        return;\n                    }\n                }\n            }\n        }\n    }\n<\/code><\/pre>\n
    \nIn diesem Fall m\u00fcssen wir neben dem aktuellen Knoten auch Informationen \u00fcber den Elternknoten speichern. Wenn 'current' null ist, wird die ben\u00f6tigte Liste in der Variablen 'parent' gespeichert. 
    \nDie Effizienz der Einf\u00fcgung wird offensichtlich die gleiche sein wie die Suche \u2014 O(log(n)).<\/p>\n
    Entfernen<\/h3>\n
    \nDas L\u00f6schen ist die komplizierteste Operation, die wir mit dem Baum durchf\u00fchren m\u00fcssen. Zun\u00e4chst m\u00fcssen wir das Element finden, das wir l\u00f6schen m\u00f6chten. Aber was kommt danach? Wenn wir seiner Referenz einfach den Wert null zuweisen, verlieren wir die Informationen \u00fcber den Teilbaum, dessen Wurzel dieser Knoten ist. Die Methoden zum L\u00f6schen in einem Baum werden in drei F\u00e4lle unterteilt.<\/p>\n
    Erster Fall. Der zu l\u00f6schende Knoten hat keine Nachfolger.<\/h4>\n
    \nWenn der zu l\u00f6schende Knoten keine Nachfolger hat, bedeutet das, dass er ein Blatt ist. Folglich k\u00f6nnen wir einfach den Feldern 'leftChild' oder 'rightChild' seines Elternteils den Wert null zuweisen. <\/p>\n
    Zweiter Fall. Der zu l\u00f6schende Knoten hat einen Nachfolger.<\/h4>\n
    \nDieser Fall ist ebenfalls nicht sehr kompliziert. Lassen Sie uns zu unserem Beispiel zur\u00fcckkehren. Angenommen, wir m\u00fcssen das Element mit dem Schl\u00fcssel 14 entfernen. Sie stimmen zu, dass es, da es das rechte Kind des Knotens mit dem Schl\u00fcssel 10 ist, jedes seiner Nachkommen (in diesem Fall das rechte) einen Schl\u00fcssel haben wird, der gr\u00f6\u00dfer als 10 ist. Daher k\u00f6nnen wir es leicht aus dem Baum \u00abherausnehmen\u00bb und den Elternknoten direkt mit dem Nachkommen des zu l\u00f6schenden Knotens verbinden, d. h. den Knoten mit dem Schl\u00fcssel 10 mit dem Knoten 13 verbinden. Eine \u00e4hnliche Situation w\u00fcrde auftreten, wenn wir einen Knoten l\u00f6schen m\u00fcssten, der das linke Kind seines Elternteils ist. Denken Sie selbst dar\u00fcber nach \u2014 die genaue Analogie. <\/p>\n
    Der dritte Fall. Der Knoten hat zwei Nachkommen<\/h4>\n
    \nDer komplizierteste Fall. Lassen Sie uns ein neues Beispiel durchgehen.<\/p>\n
    \"Bin\u00e4rbaum
    \n<\/p>\n
    Nachfolger suchen<\/h4>\n
    \n Angenommen, wir m\u00fcssen den Knoten mit dem Schl\u00fcssel 25 entfernen. Wen setzen wir an seine Stelle? Jemand aus seinen Nachkommen (Nachkommen oder Nachkommen von Nachkommen) muss Nachfolger<\/i>(die Person, die den Platz des zu l\u00f6schenden Knotens einnimmt). <\/p>\n
    Wie ermitteln Sie den Nachfolger? Es ist intuitiv klar, dass dies der Knoten im Baum ist, dessen Schl\u00fcssel der n\u00e4chstgr\u00f6\u00dfere vom zu entfernenden Knoten ist. Der Algorithmus sieht wie folgt aus: Sie m\u00fcssen zu seinem rechten Nachkommen gehen (immer zum rechten, denn, wie bereits erw\u00e4hnt, ist der Schl\u00fcssel des Nachfolgers gr\u00f6\u00dfer als der des zu entfernenden Knotens) und dann die Kette der linken Nachkommen dieses rechten Nachkommen durchlaufen. Im Beispiel m\u00fcssen wir zum Knoten mit dem Schl\u00fcssel 35 gehen und dann nach unten die Kette seiner linken Nachkommen bis zum Blatt durchlaufen \u2014 in diesem Fall besteht diese Kette nur aus dem Knoten mit dem Schl\u00fcssel 30. Streng genommen suchen wir das kleinste Element in der Menge der Knoten, die gr\u00f6\u00dfer als der gesuchte Knoten sind.<\/p>\n
    \"Bin\u00e4rbaum
    \n
    \nCode zur Methode der Nachfolgersuche:<\/p>\n
        public Node getSuccessor(Node deleteNode) {\n        Node parentSuccessor = deleteNode; \/\/ Elternteil des Nachfolgers\n        Node successor = deleteNode; \/\/ Nachfolger\n        Node current = successor.getRightChild(); \/\/ einfach \"laufender\" Knoten\n        while (current != null) {\n            parentSuccessor = successor;\n            successor = current;\n            current = current.getLeftChild();\n        }\n        \/\/ beim Verlassen der Schleife haben wir den Nachfolger und den Elternteil des Nachfolgers\n        if (successor != deleteNode.getRightChild()) { \/\/ wenn der Nachfolger nicht mit dem rechten Kind des zu l\u00f6schenden Knotens \u00fcbereinstimmt\n            parentSuccessor.setLeftChild(successor.getRightChild()); \/\/ dann \u00fcbernimmt der Elternteil den Nachfolger, um dessen Kind nicht zu verlieren\n            successor.setRightChild(deleteNode.getRightChild()); \/\/ verbinden den Nachfolger mit dem rechten Kind des zu l\u00f6schenden Knotens\n        }\n        return successor;\n    }\n<\/code><\/pre>\n
    \nDer vollst\u00e4ndige Code der Methode delete:<\/p>\n
    public boolean delete(int deleteKey) {\n        Node current = root;\n        Node parent = current;\n        boolean isLeftChild = false; \/\/ Je nach dem, ob der zu l\u00f6schende Knoten ein linkes oder rechtes Kind seines Elternteils ist, wird die boolesche Variable isLeftChild entsprechend true oder false sein.\n        while (current.getKey() != deleteKey) {\n            parent = current;\n            if (deleteKey < current.getKey()) {\n                current = current.getLeftChild();\n                isLeftChild = true;\n            } else {\n                isLeftChild = false;\n                current = current.getRightChild();\n            }\n            if (current == null)\n                return false;\n        }\n\n        if (current.getLeftChild() == null && current.getRightChild() == null) { \/\/ erster Fall\n            if (current == root)\n                current = null;\n            else if (isLeftChild)\n                parent.setLeftChild(null);\n            else\n                parent.setRightChild(null);\n        }\n        else if (current.getRightChild() == null) { \/\/ zweiter Fall\n            if (current == root)\n                root = current.getLeftChild();\n            else if (isLeftChild)\n                parent.setLeftChild(current.getLeftChild());\n            else\n                current.setRightChild(current.getLeftChild());\n        } else if (current.getLeftChild() == null) {\n            if (current == root)\n                root = current.getRightChild();\n            else if (isLeftChild)\n                parent.setLeftChild(current.getRightChild());\n            else\n                parent.setRightChild(current.getRightChild());\n        } \n        else { \/\/ dritter Fall\n            Node successor = getSuccessor(current);\n            if (current == root)\n                root = successor;\n            else if (isLeftChild)\n                parent.setLeftChild(successor);\n            else\n                parent.setRightChild(successor);\n        }\n        return true;\n    }\n<\/code><\/pre>\n
    \nDie Komplexit\u00e4t kann durch O(log(n)) approximiert werden.<\/p>\n
    Suche nach dem Maximum\/Minimum im Baum<\/h3>\n
    \nUm den minimalen\/maximalen Wert im Baum zu finden, muss man gem\u00e4\u00df der Kette der linken\/rechten Elemente des Baums nacheinander vorgehen; wenn man ein Blatt erreicht, ist es das minimale\/maximale Element.<\/p>\n
        public Node<T> getMinimum(Node<T> startPoint) {\n        Node<T> current = startPoint;\n        Node<T> parent = current;\n        while (current != null) {\n            parent = current;\n            current = current.getLeftChild();\n        }\n        return parent;\n    }\n\n    public Node<T> getMaximum(Node<T> startPoint) {\n        Node<T> current = startPoint;\n        Node<T> parent = current;\n        while (current != null) {\n            parent = current;\n            current = current.getRightChild();\n        }\n        return parent;\n    }\n<\/code><\/pre>\n
    \nDie Komplexit\u00e4t betr\u00e4gt O(log(n)).<\/p>\n
    Symmetrische Traversierung<\/h3>\n
    \nTraversierung bedeutet, jeden Knoten im Baum zu besuchen, um eine bestimmte Aktion mit ihm durchzuf\u00fchren.<\/p>\n
    Algorithmus f\u00fcr die rekursive symmetrische Traversierung:<\/p>\n
      \n
    1. Aktion mit dem linken Nachkommen durchf\u00fchren<\/li>\n
    2. Aktion mit sich selbst durchf\u00fchren<\/li>\n
    3. Aktion mit dem rechten Nachkommen durchf\u00fchren<\/li>\n<\/ol>\n
      \nCode:<\/p>\n
          public void inOrder(Node<T> current) {\n        if (current != null) {\n            inOrder(current.getLeftChild());\n            System.out.println(current.getData() + \" \");\/\/Hier kann alles M\u00f6gliche stehen\n            inOrder(current.getRightChild());\n        }\n    }\n<\/code><\/pre>\n
      <\/p>\n
      Fazit<\/h2>\n
      \nEndlich! Wenn ich etwas nicht klar genug erkl\u00e4rt habe oder Sie Anmerkungen haben, lassen Sie es mich in den Kommentaren wissen. Wie versprochen, hier ist der vollst\u00e4ndige Code.<\/p>\n
      Node.java:<\/p>\n
      public class Node {\n    private T data;\n    private int key;\n    private Node leftChild;\n    private Node rightChild;\n\n    public Node(T data, int key) {\n        this.data = data;\n        this.key = key;\n    }\n\n    public void setLeftChild(Node newNode) {\n        leftChild = newNode;\n    }\n\n    public void setRightChild(Node newNode) {\n        rightChild = newNode;\n    }\n\n    public Node getLeftChild() {\n        return leftChild;\n    }\n\n    public Node getRightChild() {\n        return rightChild;\n    }\n\n    public T getData() {\n        return data;\n    }\n\n    public int getKey() {\n        return key;\n    }\n}\n\n<\/code><\/pre>\n
      \nBinaryTree.java:<\/p>\n
      public class BinaryTree {\n    private Node root;\n\n    public Node find(int key) {\n        Node current = root;\n        while (current.getKey() != key) {\n            if (key < current.getKey())\n                current = current.getLeftChild();\n            else\n                current = current.getRightChild();\n            if (current == null)\n                return null;\n        }\n        return current;\n    }\n\n    public void insert(T insertData, int key) {\n        Node current = root;\n        Node parent;\n        Node newNode = new Node(insertData, key);\n        if (root == null)\n            root = newNode;\n        else {\n            while (true) {\n                parent = current;\n                if (key < current.getKey()) {\n                    current = current.getLeftChild();\n                    if (current == null) {\n                         parent.setLeftChild(newNode);\n                         return;\n                    }\n                }\n                else {\n                    current = current.getRightChild();\n                    if (current == null) {\n                        parent.setRightChild(newNode);\n                        return;\n                    }\n                }\n            }\n        }\n    }\n\n    public Node getMinimum(Node startPoint) {\n        Node current = startPoint;\n        Node parent = current;\n        while (current != null) {\n            parent = current;\n            current = current.getLeftChild();\n        }\n        return parent;\n    }\n\n    public Node getMaximum(Node startPoint) {\n        Node current = startPoint;\n        Node parent = current;\n        while (current != null) {\n            parent = current;\n            current = current.getRightChild();\n        }\n        return parent;\n    }\n\n    public Node getSuccessor(Node deleteNode) {\n        Node parentSuccessor = deleteNode;\n        Node successor = deleteNode;\n        Node current = successor.getRightChild();\n        while (current != null) {\n            parentSuccessor = successor;\n            successor = current;\n            current = current.getLeftChild();\n        }\n\n        if (successor != deleteNode.getRightChild()) {\n            parentSuccessor.setLeftChild(successor.getRightChild());\n            successor.setRightChild(deleteNode.getRightChild());\n        }\n        return successor;\n    }\n\n    public boolean delete(int deleteKey) {\n        Node current = root;\n        Node parent = current;\n        boolean isLeftChild = false;\n        while (current.getKey() != deleteKey) {\n            parent = current;\n            if (deleteKey < current.getKey()) {\n                current = current.getLeftChild();\n                isLeftChild = true;\n            } else {\n                isLeftChild = false;\n                current = current.getRightChild();\n            }\n            if (current == null)\n                return false;\n        }\n\n        if (current.getLeftChild() == null && current.getRightChild() == null) {\n            if (current == root)\n                current = null;\n            else if (isLeftChild)\n                parent.setLeftChild(null);\n            else\n                parent.setRightChild(null);\n        }\n        else if (current.getRightChild() == null) {\n            if (current == root)\n                root = current.getLeftChild();\n            else if (isLeftChild)\n                parent.setLeftChild(current.getLeftChild());\n            else\n                current.setRightChild(current.getLeftChild());\n        } else if (current.getLeftChild() == null) {\n            if (current == root)\n                root = current.getRightChild();\n            else if (isLeftChild)\n                parent.setLeftChild(current.getRightChild());\n            else\n                parent.setRightChild(current.getRightChild());\n        } \n        else {\n            Node successor = getSuccessor(current);\n            if (current == root)\n                root = successor;\n            else if (isLeftChild)\n                parent.setLeftChild(successor);\n            else\n                parent.setRightChild(successor);\n        }\n        return true;\n    }\n\n    public void inOrder(Node current) {\n        if (current != null) {\n            inOrder(current.getLeftChild());\n            System.out.println(current.getData() + \" \");\n            inOrder(current.getRightChild());\n        }\n    }\n}\n<\/code><\/pre>\n
      P.S.<\/h2>\n
      <\/p>\n
      Degeneration zu O(n)<\/h3>\n
      \nViele von Ihnen haben vielleicht bemerkt: Was w\u00e4re, wenn wir das Baum unbalanciert machen? Zum Beispiel, indem wir Knoten mit aufsteigenden Schl\u00fcsseln einf\u00fcgen: 1, 2, 3, 4, 5, 6\u2026 Dann \u00e4hnelt der Baum eher einer verketteten Liste. Ja, der Baum verliert seine baumartige Struktur und damit die Effizienz beim Datenzugriff. Die Komplexit\u00e4t der Such-, Einf\u00fcge- und L\u00f6schoperationen wird die gleiche wie bei einer verketteten Liste sein: O(n). Das ist einer der wichtigsten Nachteile von bin\u00e4ren B\u00e4umen aus meiner Sicht.<\/p>\n
      Nur registrierte Benutzer k\u00f6nnen an der Umfrage teilnehmen. Bitte melden Sie sich an.<\/a><\/noindex>Sind Sie an Contour interessiert?<\/p>\n
      Ich bin noch nicht lange auf Habr, und ich w\u00fcrde gerne wissen, \u00fcber welche Themen Sie mehr Artikel sehen m\u00f6chten?<\/h2>\n
        \n
      • \n
                            Datenstrukturen<\/p>\n<\/li>\n
      • \n
                            Algorithmen (DP, Rekursion, Datenkompression usw.)<\/p>\n<\/li>\n
      • \n
                            Anwendung von Datenstrukturen und Algorithmen im echten Leben<\/p>\n<\/li>\n
      • \n
                            Programmierung von Android-Anwendungen in Java<\/p>\n<\/li>\n
      • \n
                            Programmierung von Webanwendungen in Java<\/p>\n<\/li>\n<\/ul>\n
            2 Benutzer haben abgestimmt. 1 Benutzer hat sich enthalten.
        \n
        Quelle: habr.com<\/p>","protected":false,"gt_translate_keys":[{"key":"rendered","format":"html"}]},"excerpt":{"rendered":"
        \u041f\u0440\u0435\u043b\u044e\u0434\u0438\u044f \u042d\u0442\u0430 \u0441\u0442\u0430\u0442\u044c\u044f \u043f\u043e\u0441\u0432\u044f\u0449\u0435\u043d\u0430 \u0431\u0438\u043d\u0430\u0440\u043d\u044b\u043c \u0434\u0435\u0440\u0435\u0432\u044c\u044f\u043c \u043f\u043e\u0438\u0441\u043a\u0430. \u041d\u0435\u0434\u0430\u0432\u043d\u043e \u0434\u0435\u043b\u0430\u043b \u0441\u0442\u0430\u0442\u044c\u044e \u043f\u0440\u043e \u0441\u0436\u0430\u0442\u0438\u0435 \u0434\u0430\u043d\u043d\u044b\u0445 \u043c\u0435\u0442\u043e\u0434\u043e\u043c \u0425\u0430\u0444\u0444\u043c\u0430\u043d\u0430. \u0422\u0430\u043c \u044f \u043d\u0435 \u043e\u0447\u0435\u043d\u044c \u043e\u0431\u0440\u0430\u0449\u0430\u043b \u0432\u043d\u0438\u043c\u0430\u043d\u0438\u0435 \u043d\u0430 \u0431\u0438\u043d\u0430\u0440\u043d\u044b\u0435 \u0434\u0435\u0440\u0435\u0432\u044c\u044f, \u0438\u0431\u043e \u043c\u0435\u0442\u043e\u0434\u044b \u043f\u043e\u0438\u0441\u043a\u0430, \u0432\u0441\u0442\u0430\u0432\u043a\u0438, \u0443\u0434\u0430\u043b\u0435\u043d\u0438\u044f \u043d\u0435 \u0431\u044b\u043b\u0438 \u0430\u043a\u0442\u0443\u0430\u043b\u044c\u043d\u044b. \u0422\u0435\u043f\u0435\u0440\u044c \u0440\u0435\u0448\u0438\u043b \u043d\u0430\u043f\u0438\u0441\u0430\u0442\u044c \u0441\u0442\u0430\u0442\u044c\u044e \u0438\u043c\u0435\u043d\u043d\u043e \u043f\u0440\u043e \u0434\u0435\u0440\u0435\u0432\u044c\u044f. \u041f\u043e\u0436\u0430\u043b\u0443\u0439, \u043d\u0430\u0447\u043d\u0435\u043c. \u0414\u0435\u0440\u0435\u0432\u043e \u2014 \u0441\u0442\u0440\u0443\u043a\u0442\u0443\u0440\u0430 \u0434\u0430\u043d\u043d\u044b\u0445, \u0441\u043e\u0441\u0442\u043e\u044f\u0449\u0430\u044f \u0438\u0437 \u0443\u0437\u043b\u043e\u0432, \u0441\u043e\u0435\u0434\u0438\u043d\u0435\u043d\u043d\u044b\u0445 \u0440\u0435\u0431\u0440\u0430\u043c\u0438. \u041c\u043e\u0436\u043d\u043e \u0441\u043a\u0430\u0437\u0430\u0442\u044c, \u0447\u0442\u043e \u0434\u0435\u0440\u0435\u0432\u043e \u2014 […]<\/p>\n","protected":false,"gt_translate_keys":[{"key":"rendered","format":"html"}]},"author":1,"featured_media":22528,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[688],"tags":[],"class_list":["post-30530","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-administrirovanie"],"aioseo_notices":[],"aioseo_head":"\n\t\t\n\t\n\t\n\t\n\t\n\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\n","aioseo_head_json":{"title":"\ud83e\udd47Binary Tree oder wie man einen bin\u00e4ren Suchbaum erstellt | ProHoster","description":"Einleitung Dieser Artikel besch\u00e4ftigt sich mit bin\u00e4ren Suchb\u00e4umen. K\u00fcrzlich habe ich einen Artikel \u00fcber die Datenkompression nach dem Huffman-Algorithmus geschrieben. Dort habe ich den bin\u00e4ren B\u00e4umen nicht viel Aufmerksamkeit geschenkt, da die Methoden zum Suchen, Einf\u00fcgen und L\u00f6schen nicht relevant waren. Jetzt habe ich beschlossen, einen Artikel speziell \u00fcber B\u00e4ume zu schreiben. Lassen Sie uns beginnen. Ein Baum ist eine Datenstruktur, die aus Knoten besteht, die durch Kanten verbunden sind. Man kann sagen, dass ein Baum \u2014","canonical_url":"https:\/\/prohoster.info\/de\/blog\/administrirovanie\/binary-tree-ili-kak-prigotovit-binarnoe-derevo-poiska","robots":"max-image-preview:large","keywords":"","webmasterTools":{"miscellaneous":""},"schema":null,"og:locale":"de_DE","og:site_name":"ProHoster | \u041a\u0443\u043f\u0438\u0442\u044c \u043d\u0430\u0434\u0435\u0436\u043d\u044b\u0439 \u0445\u043e\u0441\u0442\u0438\u043d\u0433 \u0434\u043b\u044f \u0441\u0430\u0439\u0442\u043e\u0432 \u0441 \u0437\u0430\u0449\u0438\u0442\u043e\u0439 \u043e\u0442 DDoS, VPS VDS \u0441\u0435\u0440\u0432\u0435\u0440\u044b","og:type":"article","og:title":"\ud83e\udd47Binary Tree \u0438\u043b\u0438 \u043a\u0430\u043a \u043f\u0440\u0438\u0433\u043e\u0442\u043e\u0432\u0438\u0442\u044c \u0431\u0438\u043d\u0430\u0440\u043d\u043e\u0435 \u0434\u0435\u0440\u0435\u0432\u043e \u043f\u043e\u0438\u0441\u043a\u0430 | ProHoster","og:description":"\u041f\u0440\u0435\u043b\u044e\u0434\u0438\u044f \u042d\u0442\u0430 \u0441\u0442\u0430\u0442\u044c\u044f \u043f\u043e\u0441\u0432\u044f\u0449\u0435\u043d\u0430 \u0431\u0438\u043d\u0430\u0440\u043d\u044b\u043c \u0434\u0435\u0440\u0435\u0432\u044c\u044f\u043c \u043f\u043e\u0438\u0441\u043a\u0430. \u041d\u0435\u0434\u0430\u0432\u043d\u043e \u0434\u0435\u043b\u0430\u043b \u0441\u0442\u0430\u0442\u044c\u044e \u043f\u0440\u043e \u0441\u0436\u0430\u0442\u0438\u0435 \u0434\u0430\u043d\u043d\u044b\u0445 \u043c\u0435\u0442\u043e\u0434\u043e\u043c \u0425\u0430\u0444\u0444\u043c\u0430\u043d\u0430. \u0422\u0430\u043c \u044f \u043d\u0435 \u043e\u0447\u0435\u043d\u044c \u043e\u0431\u0440\u0430\u0449\u0430\u043b \u0432\u043d\u0438\u043c\u0430\u043d\u0438\u0435 \u043d\u0430 \u0431\u0438\u043d\u0430\u0440\u043d\u044b\u0435 \u0434\u0435\u0440\u0435\u0432\u044c\u044f, \u0438\u0431\u043e \u043c\u0435\u0442\u043e\u0434\u044b \u043f\u043e\u0438\u0441\u043a\u0430, \u0432\u0441\u0442\u0430\u0432\u043a\u0438, \u0443\u0434\u0430\u043b\u0435\u043d\u0438\u044f \u043d\u0435 \u0431\u044b\u043b\u0438 \u0430\u043a\u0442\u0443\u0430\u043b\u044c\u043d\u044b. \u0422\u0435\u043f\u0435\u0440\u044c \u0440\u0435\u0448\u0438\u043b \u043d\u0430\u043f\u0438\u0441\u0430\u0442\u044c \u0441\u0442\u0430\u0442\u044c\u044e \u0438\u043c\u0435\u043d\u043d\u043e \u043f\u0440\u043e \u0434\u0435\u0440\u0435\u0432\u044c\u044f. \u041f\u043e\u0436\u0430\u043b\u0443\u0439, \u043d\u0430\u0447\u043d\u0435\u043c. \u0414\u0435\u0440\u0435\u0432\u043e \u2014 \u0441\u0442\u0440\u0443\u043a\u0442\u0443\u0440\u0430 \u0434\u0430\u043d\u043d\u044b\u0445, \u0441\u043e\u0441\u0442\u043e\u044f\u0449\u0430\u044f \u0438\u0437 \u0443\u0437\u043b\u043e\u0432, \u0441\u043e\u0435\u0434\u0438\u043d\u0435\u043d\u043d\u044b\u0445 \u0440\u0435\u0431\u0440\u0430\u043c\u0438. \u041c\u043e\u0436\u043d\u043e \u0441\u043a\u0430\u0437\u0430\u0442\u044c, \u0447\u0442\u043e \u0434\u0435\u0440\u0435\u0432\u043e \u2014","og:url":"https:\/\/prohoster.info\/de\/blog\/administrirovanie\/binary-tree-ili-kak-prigotovit-binarnoe-derevo-poiska","og:image":"https:\/\/prohoster.info\/wp-content\/uploads\/2021\/11\/logo-350.jpg","og:image:secure_url":"https:\/\/prohoster.info\/wp-content\/uploads\/2021\/11\/logo-350.jpg","og:image:width":350,"og:image:height":350,"article:published_time":"2019-10-31T18:36:01+00:00","article:modified_time":"2019-10-31T18:36:01+00:00","article:publisher":"https:\/\/www.facebook.com\/prohoster","article:author":"https:\/\/www.facebook.com\/prohoster"},"aioseo_meta_data":{"post_id":"30530","title":null,"description":null,"keywords":null,"keyphrases":null,"primary_term":null,"canonical_url":null,"og_title":null,"og_description":null,"og_object_type":"default","og_image_type":"default","og_image_url":null,"og_image_width":null,"og_image_height":null,"og_image_custom_url":null,"og_image_custom_fields":null,"og_video":null,"og_custom_url":null,"og_article_section":null,"og_article_tags":null,"twitter_use_og":false,"twitter_card":"default","twitter_image_type":"default","twitter_image_url":null,"twitter_image_custom_url":null,"twitter_image_custom_fields":null,"twitter_title":null,"twitter_description":null,"schema":{"blockGraphs":[],"customGraphs":[],"default":{"data":{"Article":[],"Course":[],"Dataset":[],"FAQPage":[],"Movie":[],"Person":[],"Product":[],"ProductReview":[],"Car":[],"Recipe":[],"Service":[],"SoftwareApplication":[],"WebPage":[]},"graphName":"","isEnabled":true},"graphs":[]},"schema_type":null,"schema_type_options":null,"pillar_content":false,"robots_default":true,"robots_noindex":false,"robots_noarchive":false,"robots_nosnippet":false,"robots_nofollow":false,"robots_noimageindex":false,"robots_noodp":false,"robots_notranslate":false,"robots_max_snippet":null,"robots_max_videopreview":null,"robots_max_imagepreview":"large","priority":null,"frequency":null,"local_seo":null,"seo_analyzer_scan_date":"2026-01-21 01:39:20","breadcrumb_settings":null,"limit_modified_date":false,"reviewed_by":null,"ai":null,"created":"2021-03-01 03:33:27","updated":"2026-01-21 01:39:20"},"gt_translate_keys":[{"key":"link","format":"url"}],"_links":{"self":[{"href":"https:\/\/prohoster.info\/de\/wp-json\/wp\/v2\/posts\/30530","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/prohoster.info\/de\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/prohoster.info\/de\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/prohoster.info\/de\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/prohoster.info\/de\/wp-json\/wp\/v2\/comments?post=30530"}],"version-history":[{"count":0,"href":"https:\/\/prohoster.info\/de\/wp-json\/wp\/v2\/posts\/30530\/revisions"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/prohoster.info\/de\/wp-json\/wp\/v2\/media\/22528"}],"wp:attachment":[{"href":"https:\/\/prohoster.info\/de\/wp-json\/wp\/v2\/media?parent=30530"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/prohoster.info\/de\/wp-json\/wp\/v2\/categories?post=30530"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/prohoster.info\/de\/wp-json\/wp\/v2\/tags?post=30530"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}