{"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\/en\/blog\/administrirovanie\/binary-tree-ili-kak-prigotovit-binarnoe-derevo-poiska","title":{"rendered":"Binary Tree or how to prepare a binary search tree","gt_translate_keys":[{"key":"rendered","format":"text"}]},"content":{"rendered":"

Prelude<\/h2>\n

\nThis article is dedicated to binary search trees. Recently, I wrote an article about data compression using the Huffman method.<\/a><\/noindex> There, I didn\u2019t pay much attention to binary trees, as the methods of searching, inserting, and deleting were not relevant. Now I\u2019ve decided to write an article specifically about trees. Let\u2019s begin. <\/p>\n

A tree is a data structure consisting of nodes connected by edges. It can be said that a tree is a specific case of a graph. Here\u2019s an example of a tree: <\/p>\n

\"Binary
\n
\nThis is not a binary search tree! All details below!
\n<\/a><\/noindex><\/p>\n

Terminology<\/h2>\n

<\/p>\n

Root<\/h4>\n

\nThe root of the tree is the topmost node. In the example, it\u2019s node A. From the root to any other node, there can only be one path! In fact, any node can be considered as the root of the corresponding subtree.<\/i> Parents\/children<\/p>\n

All nodes except the root have exactly one edge connecting them upward to another node. The node located above the current one is called the<\/h4>\n

\nparent of this node. The node located below the current one and connected to it is called a<\/i> child of this node. Let\u2019s take an example. If we take node B, then its parent will be node A, and its children will be nodes D, E, and F.<\/i> Leaf<\/p>\n

A node with no children will be called a leaf of the tree. In the example, the leaves will be nodes D, E, F, G, I, J, K.<\/h4>\n

\nThis is the basic terminology. Other concepts will be discussed further. So, a binary tree is a tree in which each node has no more than two children. As you might have guessed, the tree in the example is not binary, as nodes B and H have more than two children. Here\u2019s an example of a binary tree:<\/p>\n

Any information can be contained in the nodes of the tree. A binary search tree is a binary tree with the following properties:<\/p>\n

\"Binary
\n
\nBoth subtrees \u2014 left and right \u2014 are binary search trees.<\/p>\n

    \n
  1. All nodes of the left subtree of any node X have data key values less than the key value of node X itself.<\/li>\n
  2. All nodes of the right subtree of any node X have data key values greater than or equal to the key value of node X itself.<\/li>\n
  3. Key <\/li>\n<\/ol>\n

    \u2014 some characteristic of the node (for example, a number). The key is needed to identify the element of the tree corresponding to this key. Example of a binary search tree:<\/i> Tree representation<\/p>\n

    \"Binary
    \n<\/p>\n

    Tree representation<\/h2>\n

    \nAs we progress, I will provide some (possibly incomplete) snippets of code to enhance your understanding. The complete code will be at the end of the article. <\/p>\n

    A tree consists of nodes. The structure of a node:<\/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\/\/... other node methods\n}\n<\/code><\/pre>\n
    \nEach node has two descendants (it\u2019s possible that the descendants leftChild and\/or rightChild may have the value null). You probably understood that in this case, data refers to the information stored in the node, while key refers to the node's key.<\/p>\n
    Now that we've understood the node, let's talk about the pressing issues related to trees. Here and further, I will refer to the concept of a binary search tree when I say 'tree'. The structure of a binary tree:<\/p>\n
    public class BinaryTree<T> {\n     private Node<T> root;\n\n    \/\/ tree methods\n}\n<\/code><\/pre>\n
    As a class field, we only need the root of the tree, because from the root, using the methods getLeftChild() and getRightChild(), you can reach any node in the tree.<\/p>\n
    Algorithms in the tree<\/h2>\n
    <\/p>\n
    Search<\/h3>\n
    \nLet's assume you have a constructed tree. How do you find the element with the key key? You need to move sequentially from the root down through the tree and compare the value key with the key of each node: if key is less than the key of the current node, move to the left child of the node; if it\u2019s greater, move to the right; if the keys are equal, the desired node is found! The corresponding code:<\/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
    \nIf current becomes equal to null, this means that the traversal has reached the end of the tree (at a conceptual level, you are in a nonexistent area of the tree \u2014 a child of a leaf).<\/p>\n
    Let's consider the efficiency of the search algorithm on a balanced tree (a tree in which nodes are distributed more or less evenly). Then the efficiency of the search will be O(log(n)), where the logarithm is base 2. Note: if there are n elements in a balanced tree, then this means that there will be log(n) base 2 levels of the tree. In the search, with each iteration of the loop, you descend one level.<\/p>\n
    Insertion<\/h3>\n
    \nIf you grasp the essence of the search, then understanding the insertion will not be difficult for you. You just need to go down to the leaf of the tree (following the descent rules outlined in the search) and become its descendant \u2014 left or right, depending on the key. Implementation:<\/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 this case, it is necessary to store information about the parent of the current node, in addition to the current node itself. When current becomes null, the parent variable will hold the leaf we need. 
    \nThe efficiency of insertion will obviously be the same as that of the search \u2014 O(log(n)).<\/p>\n
    Deletion<\/h3>\n
    \nDeletion is the most complex operation that will need to be performed with the tree. It is clear that first we need to find the element we intend to delete. But what happens next? If we simply assign its reference a null value, we will lose information about the subtree whose root is this node. Deletion methods for trees can be divided into three cases.<\/p>\n
    First case. The node to be deleted has no descendants<\/h4>\n
    \nIf the node to be deleted has no descendants, this means that it is a leaf. Therefore, we can simply assign the leftChild or rightChild fields of its parent a null value. <\/p>\n
    Second case. The node to be deleted has one descendant<\/h4>\n
    \nThis case is not too difficult either. Let's return to our example. Suppose we need to delete the element with key 14. It is clear that since it is the right descendant of the node with key 10, any of its descendants (in this case, the right one) will have a key greater than 10, so we can easily 'cut' it from the tree, connecting its parent directly to the descendant of the deleted node, i.e., connecting the node with key 10 to the node 13. A similar situation would arise if we needed to delete a node that is the left descendant of its parent. Think about this yourself \u2014 it's an exact analogy. <\/p>\n
    Third case. The node has two descendants<\/h4>\n
    \nThe most complicated case. Let's examine it with a new example.<\/p>\n
    \"Binary
    \n<\/p>\n
    Searching for a successor<\/h4>\n
    \n Suppose we need to remove a node with key 25. Who will take its place? Someone from its followers (descendants or descendants' descendants) should become the successor<\/i>(the one who will occupy the place of the removed node). <\/p>\n
    How can we determine who should be the successor? Intuitively, it is clear that this is a node in the tree whose key is the next largest from the removed node. The algorithm is as follows. We need to move to its right descendant (always to the right, because it has already been mentioned that the successor's key is greater than the key of the removed node), and then follow the chain of left descendants of this right descendant. In our example, we should go to the node with key 35, and then walk down to the leaf along the chain of its left descendants \u2014 in this case, this chain consists only of the node with key 30. Strictly speaking, we are looking for the smallest node in the set of nodes greater than the sought node.<\/p>\n
    \"Binary
    \n
    \nThe code for the successor search method:<\/p>\n
        public Node getSuccessor(Node deleteNode) {\n        Node parentSuccessor = deleteNode; \/\/ parent of the successor\n        Node successor = deleteNode; \/\/ successor\n        Node current = successor.getRightChild(); \/\/ just a \"running\" node\n        while (current != null) {\n            parentSuccessor = successor;\n            successor = current;\n            current = current.getLeftChild();\n        }\n        \/\/ at the end of the loop, we have the successor and its parent\n        if (successor != deleteNode.getRightChild()) { \/\/ if the successor does not match the right child of the removed node\n            parentSuccessor.setLeftChild(successor.getRightChild()); \/\/ then its parent takes the successor's child to not lose it\n            successor.setRightChild(deleteNode.getRightChild()); \/\/ link the successor to the right child of the removed node\n        }\n        return successor;\n    }\n<\/code><\/pre>\n
    \nThe complete code for the delete method:<\/p>\n
    public boolean delete(int deleteKey) {\n        Node current = root;\n        Node parent = current;\n        boolean isLeftChild = false; \/\/ Depending on whether the deleted node is the left or right child of its parent, the boolean variable isLeftChild will take the value true or false accordingly.\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) { \/\/ Case one\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) { \/\/ Case two\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 { \/\/ Case three\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
    \nThe complexity can be approximated to O(log(n)).<\/p>\n
    Finding the maximum\/minimum in the tree<\/h3>\n
    \nIt is clear how to find the minimum\/maximum value in the tree \u2014 you need to sequentially traverse the chain of left\/right elements of the tree respectively; when you reach a leaf, it will be the minimum\/maximum element.<\/p>\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<\/code><\/pre>\n
    \nThe complexity is O(log(n))<\/p>\n
    Symmetrical traversal<\/h3>\n
    \nTraversal \u2014 visiting each node of the tree to perform some action with it.<\/p>\n
    Algorithm for recursive symmetrical traversal:<\/p>\n
      \n
    1. Perform the action with the left child<\/li>\n
    2. Perform the action with itself<\/li>\n
    3. Perform the action with the right child<\/li>\n<\/ol>\n
      \nCode:<\/p>\n
          public void inOrder(Node current) {\n        if (current != null) {\n            inOrder(current.getLeftChild());\n            System.out.println(current.getData() + \" \"); \/\/ You can put anything here\n            inOrder(current.getRightChild());\n        }\n    }\n<\/code><\/pre>\n
      <\/p>\n
      Conclusion<\/h2>\n
      \nFinally! If I missed anything or you have any comments, I\u2019m waiting for them in the comments section. As promised, here\u2019s the complete 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<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
      Degenerating to O(n)<\/h3>\n
      \nMany of you may have noticed: what if we make the tree unbalanced? For example, adding nodes with increasing keys: 1, 2, 3, 4, 5, 6\u2026 Then the tree would resemble a linked list. And yes, the tree will lose its tree structure, and consequently, its efficiency in data access. The complexity of search, insertion, and deletion operations will be like that of a linked list: O(n). This highlights, in my opinion, one of the major drawbacks of binary trees.<\/p>\n
      Only registered users can participate in the survey. Please log in<\/a><\/noindex>, please.<\/p>\n
      I haven't been on Habr for long, and I would like to know what topics you would like to see more articles about?<\/h2>\n
        \n
      • \n
                            Data Structures<\/p>\n<\/li>\n
      • \n
                            Algorithms (DP, recursion, data compression, etc.)<\/p>\n<\/li>\n
      • \n
                            Application of data structures and algorithms in real life<\/p>\n<\/li>\n
      • \n
                            Programming Android applications in Java<\/p>\n<\/li>\n
      • \n
                            Programming web applications in Java<\/p>\n<\/li>\n<\/ul>\n
            2 users voted. 1 user abstained.
        \n
        Source: 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 or how to create a binary search tree | ProHoster","description":"Prelude This article is dedicated to binary search trees.","canonical_url":"https:\/\/prohoster.info\/en\/blog\/administrirovanie\/binary-tree-ili-kak-prigotovit-binarnoe-derevo-poiska","robots":"max-image-preview:large","keywords":"","webmasterTools":{"miscellaneous":""},"schema":null,"og:locale":"en_US","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.","og:url":"https:\/\/prohoster.info\/en\/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\/en\/wp-json\/wp\/v2\/posts\/30530","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/prohoster.info\/en\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/prohoster.info\/en\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/prohoster.info\/en\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/prohoster.info\/en\/wp-json\/wp\/v2\/comments?post=30530"}],"version-history":[{"count":0,"href":"https:\/\/prohoster.info\/en\/wp-json\/wp\/v2\/posts\/30530\/revisions"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/prohoster.info\/en\/wp-json\/wp\/v2\/media\/22528"}],"wp:attachment":[{"href":"https:\/\/prohoster.info\/en\/wp-json\/wp\/v2\/media?parent=30530"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/prohoster.info\/en\/wp-json\/wp\/v2\/categories?post=30530"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/prohoster.info\/en\/wp-json\/wp\/v2\/tags?post=30530"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}