Вставка элемента в дерево

#include <vcl.h>
#include <iostream.h>
#pragma hdrstop
 
//---------------------------------------------------------------------------
#define ALPHA_SIZE 26
struct TrieNode
     {
       int count;
       TrieNode *childList[ALPHA_SIZE];
     };
TrieNode *childList[ALPHA_SIZE];(приходется почему то объявлять вне структуры иначе не видит)
void InitTrieTree()
{
   for(int index=0;index<ALPHA_SIZE;index++)
     {childList[index]=NULL;};
      count=0;(тут компилятор выдает ошибку)
}
#pragma argsused
void main()
{
SetConsoleOutputCP(1251);
 
дальше будут вызовы всех функций
 
}

struct node {
    std::string str;
    std::list<node*> children;
    node(const std::string& s):str(s),cildren() {}
};
bool push(node *&t, const std::string& key, const std::string& newvalue)
{
    if (t!=NULL) {
        if (key == t->str) {
            t->children.push_back(new node(newvalue));
            return true;
        } else {  // key != t->str
            if (not t->children().empty()) {
                 for (std::list<node*>::iterator i=t->children.begin(); t != t->children.end(); ++i) {
                      if (push(*i, key, newvalue)) braek;
                 }
                 return true;
            } else {  // t->children().empty() == true
                 return false;
            }
        }
    } else { // t == NULL
         t = new node(newvalue);
         return true;
    }
}
void print(tree *t, int n)
{
     if (t!=NULL) {
          std::cout << t->str;
          if (not t->children.empty()) {
                std::cout << ":\n";
                for (std::list<node*>::iterator i=t->children.begin(); t != t->children.end(); ++i) {
                      for (int k=0; k!=n;++k) std::cout << "  ";
                      print(*i, n + 1);
                }
          } else {
                std::cout << ".\n";
          }
     }
}
int main() {
   node *tree = NULL;
   push(tree,"","first");
   push(tree,"first","second");
   push(tree,"first","third");
   push(tree,"first","forth");
   push(tree,"third","fifth");
   push(tree,"second","sixth");
   push(tree,"second","seventh");
   print(tree, 0);
   return 0;
}

struct node {
    std::string str;                               // строка текста - данные содержащиеся в узле.
    std::list<node*> children;               // список детей узла.
    node(const std::string& s):str(s),children() {} // конструктор, для создания узла
};

#include <iostream>
#include <string>
#include <list>
 
struct node {
    std::string str;
    std::list<node*> children;
    node(const std::string& s):str(s),children() {}
};
// добавление в дерево элемента по ключу
// возвращает true если узел был успешно вставлен в под дерево
// и false в другом случае (не нашлось указанного предка)
// key - ключ по которому ищем предка,
// newvalue - данные для нового узла.
bool push(node *&t, const std::string& key, const std::string& newvalue)
{
    // сначала надо проверить - если указатель нулевой к нему нельзя обращаться.
    if (t!=NULL) {
        if (key == t->str) {  // если этот узел тот кому у список детей надо вставить новый узел то...
            t->children.push_back(new node(newvalue)); // ... собственно вставляем новый узел.
            return true; // вставка успешная значит вернем true.
        } else {  // key != t->str, это не тот узел который должен стать родительским для нового узла...
            // ... значит надо попробовать поискать среди его детей,
            if (not t->children.empty()) { // если дети есть,
                 for (std::list<node*>::iterator i=t->children.begin(); i != t->children.end(); ++i) {
                      // проходим по списку детей и пытаемся впарить новый узел каждому из них
                      // и если получается (см. ниже) то прерываем попытки впарить ивернем true.
                      if (push(*i, key, newvalue)) break;
                 }
                 return true;
            } else {  // t->children.empty() == true - если нет детей
                 // ключ не совпадает, детей нет, искать негде - в это поддерево вставить
                 // новый узел не удалось, вернем false
                 return false;
            }
        }
    } else { // t == NULL - узла нет, такое может быть только если толкаем в корень,
         // нету узла - сделаем. И вернем true т.к. получилось добавить новый узел.
         t = new node(newvalue);
         return true;
    }
}
// вывод дерева на экран
// эту мне лень коментировать, просто логика в следующем:
// выводим текущий узел и всех его детей в списке под ним с отступом,
// чтобы была видна иерархия.
void print(node *t, int n)
{
     if (t!=NULL) {
          std::cout << t->str;
          if (not t->children.empty()) {
                std::cout << ":\n";
                for (std::list<node*>::iterator i=t->children.begin(); i != t->children.end(); ++i) {
                      for (int k=0; k!=n;++k) std::cout << "  ";
                      print(*i, n + 1);
                }
          } else {
                std::cout << ".\n";
          }
     }
}
// корректное освобождение памяти, выделенной под дерево.
// проходим по дереву и удаляем все узлы и освобождаем списки.
void del(node *&t)
{
    if (t != NULL) {
        if (not t->children.empty()) {
            for (std::list<node*>::iterator i=t->children.begin(); i != t->children.end(); ++i) {
                del(*i);
            }
            t->children.clear();
        }
        delete t;
    }
}
int main() {
   node *tree = NULL; // корень дерева
   // далее заталкиваем в дерево элементы
   push(tree,"","first");
   push(tree,"first","second");
   push(tree,"first","third");
   push(tree,"first","forth");
   push(tree,"third","fifth");
   push(tree,"second","sixth");
   push(tree,"second","seventh");
   // выводим на экран ...
   print(tree, 1);
   // ... и удаляем
   del(tree);
   return 0;
}

#include <iostream>
#include <string>
#include <list>
 
struct node {
    std::string str;
    std::list<node*> children;
    node(const std::string& s):str(s),children() {}
};
// добавление в дерево элемента по ключу
// возвращает true если узел был успешно вставлен в под дерево
// и false в другом случае (не нашлось указанного предка)
// key - ключ по которому ищем предка,
// newvalue - данные для нового узла.
bool push(node *&t, const std::string& key, const std::string& newvalue)
{
    // сначала надо проверить - если указатель нулевой к нему нельзя обращаться.
    if (t!=NULL) {
        if (key == t->str) {  // если этот узел тот кому у список детей надо вставить новый узел то...
            t->children.push_back(new node(newvalue)); // ... собственно вставляем новый узел.
            return true; // вставка успешная значит вернем true.
        } else {  // key != t->str, это не тот узел который должен стать родительским для нового узла...
            // ... значит надо попробовать поискать среди его детей,
            if (&& t->children.empty()) { // если дети есть,
                 for (std::list<node*>::iterator i=t->children.begin(); i != t->children.end(); ++i) {
                      // проходим по списку детей и пытаемся впарить новый узел каждому из них
                      // и если получается (см. ниже) то прерываем попытки впарить ивернем true.
                      if (push(*i, key, newvalue)) break;
                 }
                 return true;
            } else {  // t->children.empty() == true - если нет детей
                 // ключ не совпадает, детей нет, искать негде - в это поддерево вставить
                 // новый узел не удалось, вернем false
                 return false;
            }
        }
    } else { // t == NULL - узла нет, такое может быть только если толкаем в корень,
         // нету узла - сделаем. И вернем true т.к. получилось добавить новый узел.
         t = new node(newvalue);
         return true;
    }
}
// вывод дерева на экран
// эту мне лень коментировать, просто логика в следующем:
// выводим текущий узел и всех его детей в списке под ним с отступом,
// чтобы была видна иерархия.
void print(node *t, int n)
{
     if (t!=NULL) {
          std::cout << t->str;
          if (&& t->children.empty()) {
                std::cout << ":\n";
                for (std::list<node*>::iterator i=t->children.begin(); i != t->children.end(); ++i) {
                      for (int k=0; k!=n;++k) std::cout << "  ";
                      print(*i, n + 1);
                }
          } else {
                std::cout << ".\n";
          }
     }
}
// корректное освобождение памяти, выделенной под дерево.
// проходим по дереву и удаляем все узлы и освобождаем списки.
void del(node *&t)
{
    if (t != NULL) {
        if (&& t->children.empty()) {
            for (std::list<node*>::iterator i=t->children.begin(); i != t->children.end(); ++i) {
                del(*i);
            }
            t->children.clear();
        }
        delete t;
    }
}
int main() {
   node *tree = NULL; // корень дерева
   // далее заталкиваем в дерево элементы
   push(tree,"","first");
   push(tree,"first","second");
   push(tree,"first","third");
   push(tree,"first","forth");
   push(tree,"third","fifth");
   push(tree,"second","sixth");
   push(tree,"second","seventh");
   // выводим на экран ...
   print(tree, 1);
   // ... и удаляем
   del(tree);
   return 0;
}

struct node{
    std::string str;
    node *left, *right; // левое, правое поддеревья.
    node(const std::string& s):str(s),left(NULL),rigth(NULL) {}
};
void push(node *&t,std::string newvalue) {
    if (t != NULL) {
       if (newvalue < t->str) push(t->left, newvalue);
       else if (newvalue > t->str) push(t->right, newvalue);
       else std::cout << "Такое значение уже содержится в дереве.\n";
    } else {
       t = new node(newvalue);
    }
}
// использование
node *tree = NULL;
push(tree,"g");
push(tree,"r");
push(tree,"c");
push(tree,"b");
push(tree,"h");
push(tree,"a");
push(tree,"i");

void print(node *t, int n)
{
   if (t!=NULL) 
       {
         print(t->left, n+1);//Вывод левого поддерева
         for(int i=0;i<n;i++)cout<<" ";//Сдвиг позиции соответственно уровню
         cout<<t->str<<endl;//Вывод корня поддерева
         print(t->right, n+1);//Вывод правого поддерева
       }     
}

#include <string.h>
#include <iostream.h>
#include <vcl.h>
 
struct Tree {
Tree *child[26];
bool term;
int count;
};
 
Tree *initTree() {
Tree *T = new Tree;
for(int i = 0; i < 26; i++) {
T->child[i] = NULL;
}
T->count = 0;
T->term = false;
return T;
}
 
void addWordTree(Tree *root, char *str) {
Tree *T = root;
int length = strlen(str);
for(int i = 0; i < length; i++) {
int index = str[i] - 'a';
if(T->child[index] == NULL) {
T->child[index] = initTree();
T->count++;
}
T = T->child[index];
if(i == (length - 1)) {
T->term = true;
}
}
}
 
void printTree(Tree *T, const char *str) {
 if(T->count>0) {
  for(int i = 0; i < 26; i++) {
   if(T->child[i]) {
    string s("");
    s.assign(str);
    s.append(1, (char) (i + (int) 'a'));
    printTree(T->child[i], s.data());
   }
  }
 }
 if(T->term) cout << str << endl;
}
 
void main() {
SetConsoleOutputCP(1251);
char consonants[] = {'b', 'c', 'd', 'f', 'g', 'h', 'j', 'k', 'l', 'm', 'n', 'p', 'q', 'r', 's', 't', 'v', 'w', 'x', 'z'};
Tree *T = initTree();
 
for(int i = 0; i < 3; i++) {
int k;
char str[10];
std::cout<<"Введите ветвь дерева"<<endl;
std::cin >> str;
int l = strlen(str);
for(int j=0; j < 20; j++)
{if (str[l-1] == consonants[j]) {*str = NULL; k = 1;} }
if(k == 1){ cout<<"Строка была удалена"<<endl;} else { cout<<"Строка была успешно добавлена"<<endl;}
addWordTree(T, str);
k = 0;
}
printTree(T, "");
system("PAUSE");
}