De uma perspectiva de código-fonte ou mesmo de código de três endereços (TAC), você pode visualizar o problema realmente facilmente nesta página ...
http://cgm.cs.mcgill.ca/~hagha/topic30/topic30.html#Exptree
Se você for para a seção da árvore de expressão e, em seguida, descer um pouco a página, ela mostrará a "classificação topológica" da árvore e o algoritmo de como avaliar a expressão.
Então, nesse caso, você pode usar o DAG para avaliar expressões, o que é útil, pois a avaliação é normalmente interpretada e usar um avaliador DAG tornará os intrepretadores simples mais rápidos em princípio porque não está empurrando e saltando para uma pilha e também porque está eliminando subexpressões comuns.
O algoritmo básico para calcular o DAG em egípcio não antigo (ou seja, inglês) é este:
1) Faça seu objeto DAG assim
Você precisa de uma lista ativa e esta lista contém todos os nós e subexpressões DAG atuais ao vivo. Uma subexpressão DAG é um nó DAG, ou você também pode chamá-lo de nó interno. O que quero dizer com nó DAG ativo é que, se você atribuir a uma variável X, ela se tornará ativa. Uma subexpressão comum que então usa X usa essa instância. Se X for atribuído novamente, um NOVO DAG NODE é criado e adicionado à lista ativa e o X antigo é removido, de modo que a próxima subexpressão que usa X se referirá à nova instância e, portanto, não entrará em conflito com subexpressões que simplesmente use o mesmo nome de variável.
Depois de atribuir a uma variável X, então, por coincidência, todos os nós de subexpressão DAG que estão ativos no ponto de atribuição tornam-se inativos, pois a nova atribuição invalida o significado das subexpressões usando o valor antigo.
class Dag {
TList LiveList;
DagNode Root;
}
// In your DagNode you need a way to refer to the original things that
// the DAG is computed from. In this case I just assume an integer index
// into the list of variables and also an integer index for the opertor for
// Nodes that refer to operators. Obviously you can create sub-classes for
// different kinds of Dag Nodes.
class DagNode {
int Variable;
int Operator;// You can also use a class
DagNode Left;
DagNode Right;
DagNodeList Parents;
}
Então, o que você faz é percorrer sua árvore em seu próprio código, como uma árvore de expressões no código-fonte, por exemplo. Chame os nós existentes de XNodes, por exemplo.
Portanto, para cada XNode, você precisa decidir como adicioná-lo ao DAG, e há a possibilidade de que já esteja no DAG.
Este é um pseudocódigo muito simples. Não se destina à compilação.
DagNode XNode::GetDagNode(Dag dag) {
if (XNode.IsAssignment) {
// The assignment is a special case. A common sub expression is not
// formed by the assignment since it creates a new value.
// Evaluate the right hand side like normal
XNode.RightXNode.GetDagNode();
// And now take the variable being assigned to out of the current live list
dag.RemoveDagNodeForVariable(XNode.VariableBeingAssigned);
// Also remove all DAG sub expressions using the variable - since the new value
// makes them redundant
dag.RemoveDagExpressionsUsingVariable(XNode.VariableBeingAssigned);
// Then make a new variable in the live list in the dag, so that references to
// the variable later on will see the new dag node instead.
dag.AddDagNodeForVariable(XNode.VariableBeingAssigned);
}
else if (XNode.IsVariable) {
// A variable node has no child nodes, so you can just proces it directly
DagNode n = dag.GetDagNodeForVariable(XNode.Variable));
if (n) XNode.DagNode = n;
else {
XNode.DagNode = dag.CreateDagNodeForVariable(XNode.Variable);
}
return XNode.DagNode;
}
else if (XNode.IsOperator) {
DagNode leftDagNode = XNode.LeftXNode.GetDagNode(dag);
DagNode rightDagNode = XNode.RightXNode.GetDagNode(dag);
// Here you can observe how supplying the operator id and both operands that it
// looks in the Dags live list to check if this expression is already there. If
// it is then it returns it and that is how a common sub-expression is formed.
// This is called an internal node.
XNode.DagNode =
dag.GetOrCreateDagNodeForOperator(XNode.Operator,leftDagNode,RightDagNode) );
return XNode.DagNode;
}
}
Então essa é uma maneira de ver as coisas. Uma caminhada básica na árvore e apenas adicionar e referir-se aos nós Dag conforme avança. A raiz do dag é qualquer DagNode que a raiz da árvore retorna, por exemplo.
Obviamente, o procedimento de exemplo pode ser dividido em partes menores ou feito como subclasses com funções virtuais.
Quanto à classificação do Dag, você passa por cada DagNode da esquerda para a direita. Em outras palavras, siga a borda esquerda do DagNodes e, a seguir, a borda direita. Os números são atribuídos ao contrário. Em outras palavras, quando você atinge um DagNode sem filhos, atribua a esse Node o número de classificação atual e aumente o número de classificação, de modo que à medida que a recursão se desenrola, os números são atribuídos em ordem crescente.
Este exemplo trata apenas de árvores com nós que têm zero ou dois filhos. Obviamente, algumas árvores têm nós com mais de dois filhos, então a lógica ainda é a mesma. Em vez de calcular à esquerda e à direita, calcule da esquerda para a direita etc ...
// Most basic DAG topological ordering example.
void DagNode::OrderDAG(int* counter) {
if (this->AlreadyCounted) return;
// Count from left to right
for x = 0 to this->Children.Count-1
this->Children[x].OrderDag(counter)
// And finally number the DAG Node here after all
// the children have been numbered
this->DAGOrder = *counter;
// Increment the counter so the caller gets a higher number
*counter = *counter + 1;
// Mark as processed so will count again
this->AlreadyCounted = TRUE;
}