N-дерево

#include <iostream>
#include <stdlib.h>
#include <conio.h>
using namespace std;
 
 
const int N=10; // количество пространств ключей
 
struct Item { // структура элемента
  int key[N];  // массив ключей определяющих элемент
  char *info;  // информация элемента
};
 
struct Node { // структура узла дерева
  Item i;  // элемент
  Node *left; // левое поддерево
  Node *right; // правое поддерево
};
 
int main() { 
for (int i = 0; tree; i++) // i - это номер пространства
    if (tree->x[i] < tree->t)  // t - медиана
        tree = tree->left;     // переходим в левое поддерево
    else
        tree = tree->right;    // переходим в правое поддерево
 
return 0;
}

struct Node { // структура узла дерева
  int key; // идентификатор вершины
  Node *nodes[N]; // массив указателей на N сыновей узла
};

#include "stdafx.h"
#include <stdio.h>
#include <stdlib.h>
#include <iostream>
#include <conio.h>
struct tree {
int k,n;
tree **son;
};
tree *root=NULL; 
tree *node;
void add(tree *);
void main()
{
node=new tree;
root=node;
printf("Enter the key of the root\n");
scanf("%d",&node->k);
add(node);
getch();
}
void add(tree *c)
{
int i;
printf("Enter the number of sons\n");
scanf("%d",&c->n);
if (c->n==0) 
{
c->son=NULL;
return;
}
c->son=new tree*[c->n];
for (i=0;i<c->n;i++)
{
c->son[i]=new tree;
printf("Enter the key of the node %d\n",i);
scanf("%d",&c->son[i]->k);
printf("\n%d",c->son[i]->k);
}
for (i=0;i<c->n;i++)
add(c->son[i]);
}

#include "stdafx.h"
#include "iostream"
#include "conio.h"
using namespace std;
 
struct CNode
{
   int number; // number of node
   int data; // some node data
   unsigned int nChildCount; // amount of chidren
   CNode* pChildren; // pointer to array of child nodes
};
 
int nn = 0;
int count = 0;
 
void Zapolnenie(CNode* pNode)
{
   pNode->number = nn++;
   cout << "Vi v vershine " << pNode->number << "\nDannie uzla ";
   cin >> pNode->data;
 
   cout << "Skoka detey? ";
   unsigned int l; cin >> l;
   if (l > 0)
   {
      pNode->nChildCount = l;
      pNode->pChildren = new CNode[l];
      for (int qq = 0; qq < l; ++qq)
      {
         Zapolnenie(&pNode->pChildren[qq]);
      }
  
   }
   else
   {
      pNode->nChildCount = 0;
      pNode->pChildren = NULL;
      ++count;
   }
}
 
void Udalenie(CNode* pNode)
{
   if (pNode->nChildCount > 0)
   {
      for (int qq = 0; qq < pNode->nChildCount; ++qq)
      {
         Udalenie(&pNode->pChildren[qq]);
      }
      delete [] pNode->pChildren;
   }
}
 
int main()
{
   CNode node;
   Zapolnenie(&node);
 
   cout << "Kolichestvo list'ev: " << count;
   getch();
 
   Udalenie(&node);
 
   return 0;
}

#include <cstdio>
#include <cctype>
using namespace std;
 
int N; // определяет арность дерева
 
struct Node
{
    int v; // значение в узле дерева
    int n; // кол-во узлов в поддереве с корнем в данном узле
    Node **cld; // массив потомков
    Node() : v( 0 ), n( 1 ), cld( new Node * [ N ] ) { for ( int i = 0; i < N; ++i ) cld[ i ] = 0; }
};
 
Node *root = 0; // корень дерева
Node *msub = 0; // корень поддерева, которое надо найти по заданию
 
int parseTreeR( Node *&r, char *&s ) // парсит дерево из скобочной последовательности; возвращает кол-во узлов в поддереве
{
    int n = 0; // здесь накапливаем узлы поддерева
    int m; // не знаю как объяснить, чтобы не запутать
 
    if ( isdigit( *s ) )
    {
        r = new Node(); // создаем очередной узел дерева
        n = 1; // и запоминаем, что в поддереве с корнем в этом узле есть 1 узел
        do { r->v = r->v * 10 + *s++ - '0'; } while ( isdigit( *s ) ); // парсим значение в узле
        for ( int i = 0; i < N; ++i ) // рекурсивно парсим всех потомков
            if ( *s == '(' && ( m = parseTreeR( r->cld[ i ], ++s ) ) >= 0 && *s == ')' )
                { ++s; n += m; }
        return r->n = n;
    }
    else if ( *s == ')' ) return n; // особый случай: пустой узел ( типа такого: () )
    else return -1; // если криво ввели скобочную последовательность, то надо об этом сообщить "наверх"
}
 
bool parseTree( char *s ) // обертка над парсилкой дерева parseTreeR
{
    int m;
    if ( *s == '(' )
    {
        m = parseTreeR( root, ++s );
        if ( m == -1 ) return false;
        if ( *s == ')' && *++s == 0 ) return true;
        else return false;
    }
    return false;
}
 
void showTreeR( Node *r, int sh ) // распечатка дерева
{
    if ( !r ) return;
    for ( int j = 0; j < sh; ++j ) putchar( ' ' );
    printf( "%d\n", r->v );
    for ( int i = 0; i < N; ++i )
        showTreeR( r->cld[ i ], sh + 5 );
}
 
void showTree() // обертка над печаталкой дерева
{
    printf( "\nTree:\n\n" );
    showTreeR( root, 0 );
    printf( "\n" );
}
 
bool findMaxSubR( Node *r, int *a, int n ) // ф-ция поиска максимального поддерева с заданными свойствами
{
    if ( !r ) return true;
    
    bool flag = true;
 
    for ( int i = 0; i < N; ++i )
        flag &= findMaxSubR( r->cld[ i ], a, n );
    for ( int j = 0; j < n; ++j )
        if ( a[ j ] == r->v )
            flag = false;
    if ( flag )
        if ( !msub || msub->n < r->n )
            msub = r;
    return flag;
}
 
void findMaxSub( int *a, int n ) // обертка над findMaxSubR + распечатка результатов
{
    findMaxSubR( root, a, n );
    printf( "\nMaxSubTree:\n" );
    showTreeR( msub, 0 );
    printf( "\n" );
}
 
int main()
{
    N = 3; // задаем арность дерева
//  char s[] = "(1)";
//  char s[] = "(1(2(3)(4)))";
    char s[] = "(1(2(5(6)))(3(7(8)(2)))(4))"; // дерево в виде скобочной последовательности
 
    int a[] = { 1, 9, 4 }; // это "заданные вершины"
 
    if ( parseTree( s ) ) // если дерево удачно спарсилось из скобочной последовательности
    {
        showTree();
        findMaxSub( a, sizeof( a ) );
    }
    else
        printf( "Bad tree\n\n" );
 
    return 0;
}