include iostream include vector include string using namespace std cla

#include <iostream>
#include <vector>
#include <string>

using namespace::std;


class Node {
private:
    string data;
    long index;
    Node *parent;
    vector<Node*> children;
    void addChildren(Node *n) {
        children.push_back(n);
    }
public:
    Node(string d, long i) {
        data = d;
        index = i;
        parent = NULL;
    }
    void setParent(Node &p) {
        parent = &p;
        parent->children.push_back(this);
    }
    void setData(string d) {
        data = d;
    }
    long getIndex(){
        return index;
    }
    size_t GetCountOfChild() {
        return children.size();
    }
    Node *GetParent(){
        return parent;
    }
    
    string GetData() {
        return data;
    }
    vector<Node*> GetChildren() {
        return children;
    }
    ~Node() {

    }
};

class Tree {
private:
    vector<Node*> nodes;
    string result;
    
    void countResult(Node *node) {
        result += node->GetData();
        for (size_t i = 0; i < node->GetCountOfChild(); i++) {
            countResult(node->GetChildren()[i]);
        }
    }
public:
    Tree() {}
    void addNewNode(Node *p) {
        nodes.push_back(p);
    }
    void setParentByNodeIndex(size_t child, size_t parent) {
        getNodeByNodeIndex(child)->setParent(*getNodeByNodeIndex(parent));
    }
    void setParentByIndex(size_t child, size_t parent) {
        nodes[child]->setParent(*nodes[parent]);
    }
    void countResult() {
        for (int i = 0; i < nodes.size(); i++) {
            if (nodes[i]->GetParent() == NULL) {
                countResult(nodes[i]);
                return;
            }
        }
    }
    Node *getNodeByNodeIndex(long index) {
        for (int i = 0; i < nodes.size(); i++) {
            if (nodes[i]->getIndex() == index)
                return nodes[i];
        }
        return NULL;
    }
    Node *getNodeByIndex(size_t index) {
        return nodes[index];
    }
    Node *operator[](size_t index) {
        return getNodeByNodeIndex(index);
    }
    string Result() {
        return result;
    }
    ~Tree() {
        for (int i; i < nodes.size(); i++)
            delete nodes[i];
    }
};

int main() {
    Tree tree;
    
    tree.addNewNode(new Node("c", 1));
    tree.addNewNode(new Node("d", 2));
    tree.addNewNode(new Node("*", 3));
    
    tree.setParentByNodeIndex(1, 3);
    tree.setParentByNodeIndex(2, 3);
    
    tree.addNewNode(new Node("+", 4));
    tree.addNewNode(new Node("a", 5));
    
    tree.setParentByNodeIndex(5, 4);
    tree.setParentByNodeIndex(3, 4);

    tree.addNewNode(new Node("=", 6));
    tree.addNewNode(new Node("b", 7));
    
    tree.setParentByNodeIndex(7, 6);
    tree.setParentByNodeIndex(4, 6);
    tree.countResult();
    cout << tree.Result() << endl;
    return 0;
}