Une décharge à l'aide traverse C schéma arborescente (graphique)

Question

J'ai un schéma semblable à l'arbre graphique la structure . Je veux analyser en utilisant C dans une représentation en mémoire et marcher dessus.

Il y une bibliothèque ou extrémité avant de l'analyseur pour le faire?

EDIT:

Je l'ai analysé l'expression suivante

true && (false || true) ;
true ;
false || false 

en suivant (Ceci est mon système comme décharge d'arbre)

(PROG [(AndExp TVal(OrExp FValTVal)), TVal, (OrExp FValFVal)])

Ce que je veux traverser en C (je dois le donner à quelqu'un d'autre qui fonctionne uniquement avec C). PROG est une étiquette; AndExp, OrExp etc sont des jetons pour &&, || etc ..

Answer 1

Il semble que c'est une forme de S-expression . Peut-être Cette S-expression Parser peut être modifié pour vos besoins.

Answer 2

Je crois avoir compris vos besoins, mais pas tout à fait sûr.

Vous avez les expressions en notation préfixe, c'est donc de charger essentiellement l'expression de préfixe que vous avez dans votre fichier de vidage dans l'arbre binaire.

Voici un pseudo-code qui décrit le processus pour charger les expressions dans un arbre.

tree_node make_tree (string dump)
{
  tok1 = get_tok (dump);
  tok2 = get_tok (dump);
  tok3 = get_tok (dump);

  if (tok1 == operand)
  {
    node = make_new_node_with (tok1);
    return node;
  }

  node = make_new_node_with (tok1);
  node->left = make_tree (tok2);
  node->right = make_tree (tok3);
  return node;
}

• récursive appel 1 avec (AndExp TVal(OrExp FValTVal))

  tok1 = AndExp fait une nouvelle node1

  tok2 = TVal

  TOK3 = (OrExp FValTVal)

• récursive appel 2 avec des retours TVal node2 composez le 1 qui relie avec le pointeur gauche de node1.

• récursive appel 3 avec (OrExp FValTVal) d'appel 1.

  tok1 = ORExp fait une nouvelle node3

  tok2 = FVal

  TOK3 = TVal

• récursive appel 3 avec FVal et appel 4 avec TVal respectivement des rendements node4 et node5 avec les valeurs d'opérandes, qui sont liés aux liens à gauche et à droite de l'node3 de l'appel 3.

Plus de sous-expression à considérer, revient récursion revenir au point de départ. Vous avez la racine de l'arbre.

                         ( node1 )
                         |AndExp |
                         +---+---+
                             |
                +------------+------------+
                |                         |
            ( node2 )                ( node3 )
            | TVal  |                | ORExp |
            +---+---+                +---+---+
                                         |
                             +-----------+-----------+
                             |                       |
                         ( node4 )               ( node5 )
                         |  FVal |               |  TVal |
                         +---+---+               +---+---+ 

S'il y a plus de deux opérandes, le traitement peut être fait de la même en ajoutant des liens supplémentaires aux nœuds de l'arborescence.

Pour chaque expression dans votre fichier de vidage, qui sont séparés par des virgules aura des arbres séparés, après la création peut être déplacé.