a zadatak

#include <string>
#include <iostream>
 
struct element {
    std::string label;
    int fc,ns;
    bool used;
    element() {
        this->fc = this->ns = 0;
        this->used = false;
    }
};
 
struct tree {
    element elements[10000];
    int first;
    tree() {
        this->first = 0;
    }
};
 
int FirstChildT(int n, tree *T) {
    return T->elements[n].fc;
}
 
int NextSiblingT(int n, tree *T) { return T->elements[n].ns;}
 
std::string LabelT(int n, tree *T) { return T->elements[n].label; }
 
int RootT(tree * T) { return 1;}
 
int CreateT(std::string x, int n, tree *T) {
 
    int first_free = 1;
    while (T->elements[first_free].used) {
        first_free++;
    }
 
    T->elements[first_free].label = x;
    T->elements[first_free].used = true;
 
 
    if (!T->elements[n].fc) {
        T->elements[n].fc = first_free;
    }
 
    else {
        int bla = T->elements[n].fc;
        while (T->elements[bla].ns) {
            bla = T->elements[bla].ns;
        }
        T->elements[bla].ns = first_free;
    }
    return first_free;
}   
 
void ChangeLabelT(std::string x, int  n, tree *T) { T->elements[n].label = x;}
 
int ParentT(int n, tree *T) {
    for (int i = 1; i < 10000; ++i) {
        if (T->elements[i].fc == n) 
            return i;
        else if (T->elements[i].ns == n)
           return ParentT(i, T);
    }
    return 0;
}
 
 
 
void DeleteT(int n, tree *T) {
    std::cout << T->elements[n].ns << std::endl;
 
    if (FirstChildT(ParentT(n, T), T) == n) {
        T->elements[ParentT(n, T)].fc = T->elements[n].ns;
    }
 
    if (T->elements[n].ns == 0) {
        for (int i = 1; i < 10000; ++i) {
            if (T->elements[i].ns == n) {
                T->elements[i].ns = 0;
                break;
            }
        }
    }
 
    else {
        for (int i = 1; i < 10000; ++i) {
            if (T->elements[i].ns == n) {
                T->elements[i].ns = T->elements[n].ns;
                break;
            }
        }
 
    }
 
    T->elements[n].used = false;
}
 
void InitT(std::string x, tree  *T) { 
    T->first = 1; 
    T->elements[1].label = x;
    T->elements[1].used = true;
}