{"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\/et\/blog\/administrirovanie\/binary-tree-ili-kak-prigotovit-binarnoe-derevo-poiska","title":{"rendered":"Binaarne puu ehk kuidas valmistada binaarset otsingupuud","gt_translate_keys":[{"key":"rendered","format":"text"}]},"content":{"rendered":"

Prel\u00fc\u00fcd<\/h2>\n

\nSee artikkel k\u00e4sitleb binaarseid otsingupuusid. Hiljuti kirjutasin artikli Huffman'i meetodil andmete tihendamisest.<\/a><\/noindex> Seal ei p\u00f6\u00f6ranud ma palju t\u00e4helepanu binaarsetele puudele, kuna otsimise, lisamise ja kustutamise meetodid polnud aktuaalsed. N\u00fc\u00fcd otsustasin kirjutada artikli just puude kohta. Alustame siis. <\/p>\n

Puud on andmestruktuurid, mis koosnevad s\u00f5lmedest, mis on \u00fchendatud servadega. V\u00f5ib \u00f6elda, et puu on graafi erijuht. Siin on puu n\u00e4ide: <\/p>\n

\"Binaarne
\n
\nSee ei ole binaarne otsingupuu! K\u00f5ik allpool!
\n<\/a><\/noindex><\/p>\n

Terminoloogia<\/h2>\n

<\/p>\n

Juurepunkt<\/h4>\n

\nPuulehe juurepunkt<\/i> on selle k\u00f5ige \u00fclemine s\u00f5lm. N\u00e4ites on see s\u00f5lm A. Puust juurepunktist v\u00f5ib iga teise s\u00f5lmeni viia ainult \u00fcks tee! Tegelikult saab \u00fchtegi s\u00f5lme k\u00e4sitleda vastava alampuu juurepunktina.<\/p>\n

Vanemad\/ajalugu<\/h4>\n

\nK\u00f5ik s\u00f5lmed, v\u00e4lja arvatud juurepunkt, omavad t\u00e4pselt \u00fchte serva, mis viib \u00fclespoole teise s\u00f5lmeni. S\u00f5lm, mis asub praegusest k\u00f5rgemal, nimetatakse vanemaks<\/i> selle s\u00f5lme jaoks. S\u00f5lm, mis asub praegusest allpool ja on sellega \u00fchendatud, nimetatakse j\u00e4reltulijaks<\/i> selle s\u00f5lme jaoks. V\u00f5tame n\u00e4iteks s\u00f5lme B, siis tema vanem on s\u00f5lm A ja j\u00e4reltulijad on s\u00f5lmed D, E ja F.<\/p>\n

Leht<\/h4>\n

\nPuu s\u00f5lmed, millel ei ole j\u00e4rgnenud s\u00f5lmi, nimetatakse puu lehtedeks. Antud n\u00e4ites on lehtedeks s\u00f5lmed D, E, F, G, I, J, K.<\/p>\n

See on p\u00f5hiterminoloogia. Teised m\u00f5isted k\u00e4sitletakse hiljem. Nii on binaarne puu puu, millel igal s\u00f5lmel on mitte rohkem kui kaks j\u00e4rglast. Nagu arvatavasti teate, ei ole antud puu binaarne, kuna s\u00f5lmed B ja H omavad rohkem kui kahte j\u00e4rglast. Siin on n\u00e4ide binaarsest puust:<\/p>\n

\"Binaarne
\n
\nPuu s\u00f5lmedes v\u00f5ib paikneda mis tahes teave. Binaarne otsingu puu on binaarne puu, millel on j\u00e4rgmised omadused:<\/p>\n

    \n
  1. M\u00f5lemad alampuud \u2014 vasak ja parem \u2014 on binaarsed otsingu puud.<\/li>\n
  2. K\u00f5ik vasakpoolse alampuu s\u00f5lmed mistahes s\u00f5lme X puhul on andmekohtade v\u00f5tmete v\u00e4\u00e4rtused v\u00e4iksemad kui s\u00f5lme X enda v\u00f5tme v\u00e4\u00e4rtus.<\/li>\n
  3. K\u00f5ik parempoolse alampuu s\u00f5lmed mistahes s\u00f5lme X puhul on andmekohtade v\u00f5tmete v\u00e4\u00e4rtused suuremad v\u00f5i v\u00f5rdsed kui s\u00f5lme X enda v\u00f5tme v\u00e4\u00e4rtus. <\/li>\n<\/ol>\n

    Ala<\/i> \u2014 m\u00f5ni s\u00f5lme omadus (n\u00e4iteks number). V\u00f5ti on vajalik, et leida puu element, millele see v\u00f5ti vastab. N\u00e4ide binaarsest otsingu puust:<\/p>\n

    \"Binaarne
    \n<\/p>\n

    Puu esitus<\/h2>\n

    \nEtenemisprotsessis toon ma v\u00e4lja m\u00f5ned (v\u00f5imalikult mitte t\u00e4ielikud) koodil\u00f5igud, et aidata teil paremini m\u00f5ista. T\u00e4ielik kood on artikli l\u00f5pus. <\/p>\n

    Puu koosneb s\u00f5lmedest. S\u00f5lme struktuur:<\/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    public Node getLeftChild() {\n        return leftChild;\n    }\n\n    public Node getRightChild() {\n        return rightChild;\n    }\n\/\/...muud s\u00f5lme meetodid\n}\n<\/code><\/pre>\n
    \nIgal s\u00f5lmel on kaks last (t\u00f5en\u00e4oliselt v\u00f5ivad leftChild ja\/v\u00f5i rightChild sisaldada v\u00e4\u00e4rtust null). Olete ilmselt aru saanud, et antud juhul number data on s\u00f5lmes hoitavad andmed; key on s\u00f5lme v\u00f5ti.<\/p>\n
    N\u00fc\u00fcd, kui oleme s\u00f5lmega tutvunud, r\u00e4\u00e4gime puude p\u00e4evakajalistest probleemidest. Siin ja edaspidi m\u00f5istan s\u00f5na \"puu\" all binaarse otsingu puu m\u00f5istet. Binaarse puu struktuur:<\/p>\n
    public class BinaryTree {\n     private Node root;\n\n    \/\/puu meetodid\n}\n<\/code><\/pre>\n
    Klassi v\u00e4ljana vajame ainult puu juuri, kuna juuri kaudu on v\u00f5imalik meetodite getLeftChild() ja getRightChild() abil p\u00e4\u00e4seda iga puu s\u00f5lmeni.<\/p>\n
    Algoritmid puus<\/h2>\n
    <\/p>\n
    Otsi<\/h3>\n
    \nOletame, et teil on loodud puu. Kuidas leida elementi, millel on v\u00f5ti key? Tuleb j\u00e4rk-j\u00e4rgult liikuda juurest allapoole puu ja v\u00f5rrelda v\u00e4\u00e4rtust key j\u00e4rgmise s\u00f5lme v\u00f5tmega: kui key on v\u00e4iksem kui j\u00e4rgmise s\u00f5lme v\u00f5ti, siis liikuda s\u00f5lme vasakule alampuudule, kui suurem \u2014 paremale, kui v\u00f5tmed on v\u00f5rdsed \u2014 otsitav s\u00f5lm on leitud! Vastav kood:<\/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
    \nKui current muutub nulliks, t\u00e4hendab see, et l\u00e4bimine on j\u00f5udnud puu l\u00f5ppu (kontseptuaalses m\u00f5ttes viibite te puudulikkuse koha \u2014 lehes oleva j\u00e4rglase juures).<\/p>\n
    Vaadakem otsingu algoritmi efektiivsust tasakaalustatud puus (puus, kus s\u00f5lmed on jaotatud enam-v\u00e4hem \u00fchtlaselt). Seega on otsingu efektiivsus O(log(n)), kusjuures logaritm on alus 2. N\u00e4iteks: kui tasakaalustatud puus on n elementi, t\u00e4hendab see, et puu taset on log(n) alusel 2. Ja otsingus, \u00fche ts\u00fckli sammu jooksul, laskute \u00fche taseme v\u00f5rra.<\/p>\n
    Sisestamine<\/h3>\n
    \nKui olete otsimise m\u00f5tte tabanud, siis ei tohiks lisamine teile raskusi valmistada. Tuleb lihtsalt laskuda puu lehte (langemise reeglite kohaselt, nagu on kirjas otsingus) ja saada selle j\u00e4reltulijaks \u2014 vasakuks v\u00f5i paremaks, s\u00f5ltuvalt v\u00f5tmest. Teostus:<\/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
    \nSellisel juhul tuleb lisaks praegusele s\u00f5lmele hoida teavet ka praeguse s\u00f5lme vanema kohta. Kui current saab nulliks, sisaldab muutuja parent vajalikku lehte. 
    \nSisestamise efektiivsus on kindlasti sama mis otsimise puhul \u2014 O(log(n)).<\/p>\n
    Kustuta<\/h3>\n
    \nKustutamine on k\u00f5ige keerulisem toiming, mida puu juures teha tuleb. Esiteks tuleb leida element, mille me kavatseme eemaldada. Aga mis siis edasi? Kui lihtsalt m\u00e4\u00e4rata selle viide v\u00e4\u00e4rtusele null, kaotame me teabe selle alampuu kohta, mille juureks on see s\u00f5lm. Puu eemaldamise meetodid jagunevad kolme juhtumi vahel.<\/p>\n
    Esimene juhtum. Eemaldatav s\u00f5lm ei oma j\u00e4reltulijaid.<\/h4>\n
    \nKui eemaldatav s\u00f5lm ei oma j\u00e4reltulijaid, siis t\u00e4hendab see, et ta on leht. Seega v\u00f5ib lihtsalt m\u00e4\u00e4rata tema vanema leftChild v\u00f5i rightChild v\u00e4ljadele v\u00e4\u00e4rtuse null. <\/p>\n
    Teine juhtum. Eemaldatav s\u00f5lm omab \u00fchte j\u00e4reltulijat.<\/h4>\n
    \nSee juht ei ole ka eriti keeruline. Naaseme meie n\u00e4ite juurde. Oletame, et peame eemaldama elemendi, mille v\u00f5tme number on 14. N\u00f5ustute, et kuna see on parempoolne j\u00e4reltulija s\u00f5lme, mille v\u00f5tme number on 10, siis igal tema j\u00e4reltulijal (antud juhul parempoolsel) on kindlasti v\u00f5tme number, mis on suurem kui 10. Seega saab selle lihtsasti \u201ev\u00e4lja l\u00f5igata\u201c puust, ning vanemate s\u00f5lme saab otse \u00fchendada eemaldatava s\u00f5lme j\u00e4reltulijaga, st s\u00f5lm, mille v\u00f5tme number on 10, saab \u00fchendatud s\u00f5lmega 13. Sarnane olukord oleks ka siis, kui peaksime eemaldama s\u00f5lme, mis on tema vanema vasak j\u00e4reltulija. M\u00f5elge sellele ise \u2014 t\u00e4pselt analoogne. <\/p>\n
    Kolmas juhtum. S\u00f5lm omab kahte j\u00e4reltulijat.<\/h4>\n
    \n\u00d5ige keerulisem juhtum. Lahkame selle uue n\u00e4ite p\u00f5hjal.<\/p>\n
    \"Binaarne
    \n<\/p>\n
    J\u00e4reltulija otsimine.<\/h4>\n
    \n Oletame, et peame eemaldama s\u00f5lme, mille v\u00f5tme number on 25. Keda paneme tema asemele? Keegi tema j\u00e4rgmistest (j\u00e4reltulijatest v\u00f5i j\u00e4reltulijate j\u00e4reltulijatest) peaks saama j\u00e4reltulijaks.<\/i>(see, kes asendab eemaldatavat s\u00f5lme). <\/p>\n
    Kuidas m\u00f5ista, kes peab olema j\u00e4rglane? Intuitiivselt on selge, et see on puu s\u00f5lm, mille v\u00f5ti on eemaldatava s\u00f5lme j\u00e4rgmiseks suuruseks. Algoritm on j\u00e4rgmine. Tuleb minna selle paremale j\u00e4reltulijale (aina paremale, sest on juba \u00f6eldud, et j\u00e4rglase v\u00f5ti on suurem eemaldatava s\u00f5lme v\u00f5tmel), ja siis liikuda selle parema j\u00e4reltulija vasakute j\u00e4reltulijate ahelas. N\u00e4ites peame liikuma s\u00f5lme juurde, mille v\u00f5ti on 35, ja seej\u00e4rel liikuma alla lehe kaudu tema vasakute j\u00e4reltulijate ahelas \u2014 antud juhul koosneb see ahel vaid s\u00f5lmest, mille v\u00f5ti on 30. Rangelt \u00f6eldes otsime me v\u00e4ikseimat s\u00f5lme nende s\u00f5lmede kogumis, mis on otsitavast s\u00f5lmest suuremad.<\/p>\n
    \"Binaarne
    \n
    \nJ\u00e4rglase otsimise meetodi kood:<\/p>\n
        public Node getSuccessor(Node deleteNode) {\n        Node parentSuccessor = deleteNode; \/\/ vanema j\u00e4rglane\n        Node successor = deleteNode; \/\/ j\u00e4rglane\n        Node current = successor.getRightChild(); \/\/ lihtsalt \"l\u00e4biv\" s\u00f5lm\n        while (current != null) {\n            parentSuccessor = successor;\n            successor = current;\n            current = current.getLeftChild();\n        }\n        \/\/ ts\u00fcklist v\u00e4ljudes on meil j\u00e4rglane ja vanema j\u00e4rglane\n        if (successor != deleteNode.getRightChild()) { \/\/ kui j\u00e4rglane ei \u00fchti kustutatava s\u00f5lme parema lapsega\n            parentSuccessor.setLeftChild(successor.getRightChild()); \/\/ siis tema vanem v\u00f5tab j\u00e4rglase j\u00e4reltulija, et seda mitte kaotada\n            successor.setRightChild(deleteNode.getRightChild()); \/\/ seome j\u00e4rglase kustutatava s\u00f5lme parema lapsega\n        }\n        return successor;\n    }\n<\/code><\/pre>\n
    \nKogu delete meetodi kood:<\/p>\n
    public boolean delete(int deleteKey) {\n        Node current = root;\n        Node parent = current;\n        boolean isLeftChild = false; \/\/ S\u00f5ltuvalt sellest, kas kustutatav s\u00f5lm on oma vanemast vasak v\u00f5i parem j\u00e4reltulija, omandab loogiline muutuja isLeftChild v\u00e4\u00e4rtuse true v\u00f5i false vastavalt.\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) { \/\/ esimene juhtum\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) { \/\/ teine juhtum\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 { \/\/ kolmas juhtum\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
    \nAja v\u00f5ib hinnata O(log(n))-ks.<\/p>\n
    Maksimaalse\/minimaalse otsimine puus<\/h3>\n
    \nIlmselgelt, kuidas leida puus minimaalne\/maximaalne v\u00e4\u00e4rtus \u2014 tuleb j\u00e4rjestikku liikuda puu vasakute\/paretute elementide kaudu; kui j\u00f5uad lehtedeni, on see minimaalne\/maximaalne 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
    \nAja keerukus \u2014 O(log(n))<\/p>\n
    S\u00fcmbiootiline l\u00e4bimine<\/h3>\n
    \nL\u00e4bimine \u2014 iga puu s\u00f5lme k\u00fclastamine tegevuse sooritamiseks.<\/p>\n
    Rekursiivse s\u00fcmbiootilise l\u00e4bimise algoritm:<\/p>\n
      \n
    1. Teha tegevus vasakul lapsel<\/li>\n
    2. Teha tegevus endaga<\/li>\n
    3. Teha tegevus paremal lapsel<\/li>\n<\/ol>\n
      \nKood:<\/p>\n
          public void inOrder(Node<T> current) {\n        if (current != null) {\n            inOrder(current.getLeftChild());\n            System.out.println(current.getData() + \" \");\/\/Siin v\u00f5ib olla mis iganes\n            inOrder(current.getRightChild());\n        }\n    }\n<\/code><\/pre>\n
      <\/p>\n
      Kokkuv\u00f5te<\/h2>\n
      \nL\u00f5puks! Kui ma midagi ei selgitanud v\u00f5i on mingeid m\u00e4rkusi, ootan neid kommentaarides. Nagu lubatud, esitan t\u00e4is koodi.<\/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<T> {\n    private Node<T> root;\n\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\n    public void insert(T insertData, int key) {\n        Node<T> current = root;\n        Node<T> parent;\n        Node<T> 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<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\n    public Node<T> getSuccessor(Node<T> deleteNode) {\n        Node<T> parentSuccessor = deleteNode;\n        Node<T> successor = deleteNode;\n        Node<T> 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<T> current = root;\n        Node<T> 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<T> 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<T> 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
      Langenemine O(n) tasemeni<\/h3>\n
      \nPaljud teist on v\u00f5ib-olla m\u00e4rganud, et mis juhtub, kui puud pole tasakaalus? N\u00e4iteks, kui panna puusse j\u00e4rjestikuseid s\u00f5lmi: 1, 2, 3, 4, 5, 6\u2026 Siis meenutab puu pigem \u00fchendatud loendit. Ja jah, puu kaotab oma puulise struktuuri, seega ka andmete juurdep\u00e4\u00e4su efektiivsuse. Otsingu, sisestamise ja kustutamise keerukus muutub sarnaseks \u00fchendatud loendi omadega: O(n). See on \u00fcks olulisemaid, minu arvates, kahjusid, mis tulenevad binaarsetest puudest.<\/p>\n
      Ainult registreeritud kasutajad saavad k\u00fcsitluses osaleda. Logige sisse<\/a><\/noindex>, palun.<\/p>\n
      Ma olen hubastes hiljuti ning sooviksin teada, milliseid teemasid sooviksite rohkem n\u00e4ha?<\/h2>\n
        \n
      • \n
                            Andmestruktuurid<\/p>\n<\/li>\n
      • \n
                            Algoritmid (D\u00fcnaamiline programmeerimine, rekurssioon, andmete tihendamine jne.)<\/p>\n<\/li>\n
      • \n
                            Andmestruktuuride ja algoritmide rakendamine reaalses elus<\/p>\n<\/li>\n
      • \n
                            Android-rakenduste programmeerimine Java-s<\/p>\n<\/li>\n
      • \n
                            Veebirakenduste programmeerimine Java-s<\/p>\n<\/li>\n<\/ul>\n
            H\u00e4\u00e4letas 2 kasutajat. 1 kasutaja hoidub.
        \n
        Allikas: 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\udd47Binaarpuu v\u00f5i kuidas valmistada binaarset otsingupuud | ProHoster","description":"Sissejuhatus See artikkel k\u00e4sitleb binaarseid otsingupuid. Hiljuti kirjutasin artikli Huffmani andmete kokkusurumismeetodist. Seal ei p\u00f6\u00f6ranud ma binaarsetele puudele palju t\u00e4helepanu, kuna otsingu-, sisestamis- ja kustutamismeetodid ei olnud aktuaalsed. N\u00fc\u00fcd otsustasin kirjutada artikli just puude kohta. Alustame. Puud on andmestruktuur, mis koosneb s\u00f5lmedest, mis on omavahel \u00fchendatud harudega. V\u00f5ib \u00f6elda, et puu on","canonical_url":"https:\/\/prohoster.info\/et\/blog\/administrirovanie\/binary-tree-ili-kak-prigotovit-binarnoe-derevo-poiska","robots":"max-image-preview:large","keywords":"","webmasterTools":{"miscellaneous":""},"schema":null,"og:locale":"et_EE","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\/et\/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","focus_keyword":null,"additional_keywords":null,"truseo_locale":null},"gt_translate_keys":[{"key":"link","format":"url"}],"_links":{"self":[{"href":"https:\/\/prohoster.info\/et\/wp-json\/wp\/v2\/posts\/30530","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/prohoster.info\/et\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/prohoster.info\/et\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/prohoster.info\/et\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/prohoster.info\/et\/wp-json\/wp\/v2\/comments?post=30530"}],"version-history":[{"count":0,"href":"https:\/\/prohoster.info\/et\/wp-json\/wp\/v2\/posts\/30530\/revisions"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/prohoster.info\/et\/wp-json\/wp\/v2\/media\/22528"}],"wp:attachment":[{"href":"https:\/\/prohoster.info\/et\/wp-json\/wp\/v2\/media?parent=30530"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/prohoster.info\/et\/wp-json\/wp\/v2\/categories?post=30530"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/prohoster.info\/et\/wp-json\/wp\/v2\/tags?post=30530"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}