Desde la perspectiva del código fuente o incluso del código de tres direcciones (TAC), puede visualizar el problema con mucha facilidad en esta página ...
http://cgm.cs.mcgill.ca/~hagha/topic30/topic30.html#Exptree
Si va a la sección del árbol de expresiones y luego avanza un poco la página, se muestra la "clasificación topológica" del árbol y el algoritmo de cómo evaluar la expresión.
Entonces, en ese caso, puede usar el DAG para evaluar expresiones, lo cual es útil ya que la evaluación normalmente se interpreta y el uso de dicho evaluador DAG hará que los intérpretes simples sean más rápidos en principio porque no está empujando y saliendo a una pila y también porque está eliminando sub-expresiones comunes.
El algoritmo básico para calcular el DAG en egipcio no antiguo (es decir, inglés) es este:
1) Haga su objeto DAG así
Necesita una lista en vivo y esta lista contiene todos los nodos y sub-expresiones de DAG en vivo actuales. Una subexpresión DAG es un nodo DAG, o también puede llamarlo nodo interno. Lo que quiero decir con Nodo DAG en vivo es que si asigna a una variable X, se convierte en vivo. Una subexpresión común que luego usa X usa esa instancia. Si se vuelve a asignar X, se crea un NUEVO NODO DAG y se agrega a la lista en vivo y se elimina la X anterior, por lo que la siguiente subexpresión que usa X se referirá a la nueva instancia y, por lo tanto, no entrará en conflicto con las subexpresiones que simplemente use el mismo nombre de variable.
Una vez que asigna a una variable X, casualmente todos los nodos de subexpresión DAG que están activos en el punto de asignación se vuelven inactivos, ya que la nueva asignación invalida el significado de las subexpresiones que utilizan el valor anterior.
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;
}
Entonces, lo que hace es recorrer su árbol en su propio código, como un árbol de expresiones en el código fuente, por ejemplo. Llame a los nodos existentes XNodes, por ejemplo.
Entonces, para cada XNode, debe decidir cómo agregarlo al DAG, y existe la posibilidad de que ya esté en el DAG.
Este es un pseudocódigo muy simple. No destinado a la compilación.
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;
}
}
Así que esa es una forma de verlo. Una caminata básica del árbol y simplemente agregando y refiriéndose a los nodos Dag a medida que avanza. La raíz del dag es cualquier DagNode que devuelva la raíz del árbol, por ejemplo.
Obviamente, el procedimiento de ejemplo puede dividirse en partes más pequeñas o crearse como subclases con funciones virtuales.
En cuanto a clasificar el Dag, recorre cada DagNode de izquierda a derecha. En otras palabras, siga el borde izquierdo de DagNodes y luego el borde derecho. Los números se asignan al revés. En otras palabras, cuando llegue a un DagNode sin hijos, asigne a ese Nodo el número de clasificación actual e incremente el número de clasificación, de modo que a medida que la recursividad se deshaga, los números se asignan en orden creciente.
Este ejemplo solo maneja árboles con nodos que tienen cero o dos hijos. Obviamente, algunos árboles tienen nodos con más de dos hijos, por lo que la lógica sigue siendo la misma. En lugar de calcular de izquierda a derecha, calcula de izquierda a derecha, 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;
}