Arbre avec plusieurs nœuds enfants et nœud suivant

Je veux construire un arbre avec les caractéristiques suivantes:

  1. Chaque nœud peut avoir 1 "nœud".
  2. Chaque nœud peut avoir plusieurs nœuds enfants.
  3. Le nombre de nœuds enfants peuvent varier d'un nœud à l'autre

Je pensais à une structure qui ressemblait à ceci:

struct tree {
  int value;
  struct tree* nextnode;
  struct tree** childnode;
};

Le nombre d'enfants à chaque nœud doit être paramétrées. Je ne suis pas sûr de la façon de le faire. Merci à l'avance!

Modifier: Permettez-moi d'essayer de la définir à l'aide d'un exemple: prenons le nœud de départ. Maintenant, je vais vous définir au moment de la compilation qu'il y aura 3 NextNodes et chacun de ces NextNodes aura 2 ChildNodes. C'est à Depth=0. Au Depth = 1 (c'est à dire pour chaque nœud enfant de Depth=0) je précise qu'il y aura 4 NextNodes et pour chacune de ces NextNodes il y aura 3 ChildNodes et ainsi de suite. De l'espoir, je suis en mesure de l'exprimer correctement. S'il vous plaît ne demandez si je suis pas clair quelque part.

Edit2: Voici une photo:

Arbre avec plusieurs nœuds enfants et nœud suivant

Vous structure de données a l'air bien; il n'est pas clair que la question est.
Amicale astuce: Si ce sont les devoirs, n'oubliez pas de balise en tant que tel!
Cela devrait être votre réponse codereview.stackexchange.com/questions/569/.... Voir le code qui est en cause. Et codegolf.stackexchange.com/questions/339/binary-tree-encoding.
Si le problème est de savoir comment allouer de la mémoire dynamiquement afin de prendre en compte un nombre variable de enfants, je suggère fortement à l'aide de conteneurs STL plus smart pointeurs plutôt que brut de pointeurs.
Vous devriez état plus du problème à résoudre, plutôt que de les problèmes avec votre solution. Quelles sont les exigences? Ce qui ne l' nextnode pointeur de la représenter? Il est habituel de mettre en œuvre les arbres avec un nombre inconnu d'enfants par nœud avec un seul first_child pointeur dans le parent et un next_node (ou next_sibling) liste des formulaires de la liste des enfants, mais dans ce cas, childNode devrait être struct tree* childNode; (pour représenter le pointeur vers le premier enfant, à partir de laquelle commencer à parcourir childnode->nextnode pour le reste de la fratrie). Est-ce que vous est-il destiné?

OriginalL'auteur user560913 | 2011-06-17

  1. 1

    Vous pouvez utiliser Coup de pouce.Graphique bibliothèque.

    Très compliqué au premier abord, mais de fournir un stockage de données efficaces et hautement optimisé graphique des implémentations d'algorithmes.

    À partir du site:

    Algorithmes

    La BGL algorithmes consistent en un ensemble de base de l'algorithme de motifs (mis en œuvre comme des algorithmes génériques) et un plus grand ensemble d'algorithmes sur les graphes. L'algorithme de base des modèles sont

    • Largeur De Recherche
    • Parcours En Profondeur D'Abord De Recherche
    • Coût Uniforme De Recherche

    Par eux-mêmes, l'algorithme tendances ne calcule pas significative les quantités de plus de graphiques; ils sont simplement des blocs de construction pour la construction d'algorithmes sur les graphes. Les algorithmes de graphes dans la BGL actuellement

    • Dijkstra plus court Chemins
    • Bellman-Ford Chemins Les Plus Courts
    • Johnson Toutes les Paires de Chemins les plus courts
    • Kruskal Minimum Spanning Tree
    • Prim Minimum Spanning Tree
    • Composants Connectés
    • Fortement Composants Connectés
    • Dynamique de Composants Connectés (à l'aide d'Ensembles Disjoints)
    • Tri Topologique Transposer
    • Inverse Cuthill Mckee Commande
    • Plus Petit Dernier Sommet De La Commande
    • Séquentielle Sommet De Coloriage

    Structures De Données

    La BGL propose actuellement deux graphe des classes et une arête de la liste de l'adaptateur:

    • adjacency_list
    • adjacency_matrix
    • edge_list

    La adjacency_list classe est l'objectif général de “couteau suisse” du graphe des classes. Il est hautement paramétrable, de sorte qu'il peut être optimisé pour différentes situations: le graphe est orienté ou non orienté, d'autoriser ou d'interdire des bords parallèles, d'un accès efficace à tout les hors-bords ou aussi pour les bords, rapide sommet d'insertion et de retrait au prix d'espace supplémentaire, les frais généraux, etc.

    La adjacency_matrix catégorie magasins de bords dans un |V| x |V| matrice (|V| est le nombre de sommets). Les éléments de cette matrice représentent les arêtes dans le graphe. Matrice de contiguïté représentations sont particulièrement adaptés pour les très dense graphiques, c'est à dire, celles où le nombre d'arêtes approches |V|2.

    La edge_list classe est un adaptateur qui prend toute sorte de bord itérateur et met en œuvre un Bord de Liste Graphique.

    OriginalL'auteur 9dan

  2. 0

    C'est un N-aire arbre. Je vous suggère de split, dans l'Arbre et le Nœud

    typedef struct tree tree;
typedef struct node node;

struct tree {
    node * root;
};

struct node {
    int value;
    node * next_node;
};

    maintenant, vous pouvez effectuer tout le fonctionnement de la structure de l'arbre

    ici un exemple

    node * add_child(node *parent, int child_value){
    node * child = malloc(sizeof(node));
    child->value = child_value;
    if(parent->next == NULL)
        parent->next = child;
    else{
        node * temp = parent->next;
        while(temp->next != NULL)
            temp = temp->next;
        temp->next = child;
    }
    return child;
}
    Ce n'est pas juste une seule liste liée
    Et pourquoi chld au lieu de child?

    OriginalL'auteur apprentice