Aus der Perspektive eines Quellcodes oder sogar eines TAC-Codes (Three Address) können Sie das Problem auf dieser Seite ganz einfach visualisieren ...
http://cgm.cs.mcgill.ca/~hagha/topic30/topic30.html#Exptree
Wenn Sie zum Abschnitt mit dem Ausdrucksbaum gehen und dann ein wenig nach unten blättern, werden die "topologische Sortierung" des Baums und der Algorithmus zur Bewertung des Ausdrucks angezeigt.
In diesem Fall können Sie die DAG zum Auswerten von Ausdrücken verwenden. Dies ist praktisch, da die Auswertung normalerweise interpretiert wird und die Verwendung eines solchen DAG-Auswerters einfache Interpretatoren im Prinzip schneller macht, da sie nicht auf einen Stapel verschoben und verschoben werden und auch eliminiert werden gebräuchliche Unterausdrücke.
Der grundlegende Algorithmus zur Berechnung der DAG in nicht altägyptischem (dh Englisch) ist folgender:
1) Machen Sie Ihr DAG-Objekt so
Sie benötigen eine Live-Liste und diese Liste enthält alle aktuellen Live-DAG-Knoten und DAG-Unterausdrücke. Ein DAG-Unterausdruck ist ein DAG-Knoten, oder Sie können ihn auch als internen Knoten bezeichnen. Was ich unter Live-DAG-Knoten verstehe, ist, dass wenn Sie einer Variablen X zuweisen, diese live wird. Ein allgemeiner Unterausdruck, der dann X verwendet, verwendet diese Instanz. Wenn X erneut zugewiesen wird, wird ein NEUER DAG-NODE erstellt und zur Live-Liste hinzugefügt, und das alte X wird entfernt, sodass der nächste Unterausdruck, der X verwendet, auf die neue Instanz verweist und somit nicht mit diesen Unterausdrücken in Konflikt steht Verwenden Sie lediglich denselben Variablennamen.
Sobald Sie einer Variablen X zugewiesen haben, werden zufällig alle DAG-Unterausdrucksknoten, die zum Zeitpunkt der Zuweisung aktiv sind, nicht mehr aktiv, da die neue Zuweisung die Bedeutung von Unterausdrücken unter Verwendung des alten Werts ungültig macht.
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;
}
Sie gehen also in Ihrem eigenen Code durch Ihren Baum, z. B. in einem Ausdrucksbaum im Quellcode. Rufen Sie beispielsweise die vorhandenen Knoten XNodes auf.
Für jeden XNode müssen Sie also entscheiden, wie er zur DAG hinzugefügt werden soll, und es besteht die Möglichkeit, dass er sich bereits in der DAG befindet.
Dies ist ein sehr einfacher Pseudocode. Nicht zum Zusammenstellen gedacht.
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;
}
}
Das ist also eine Sichtweise. Ein einfacher Spaziergang durch den Baum und das Hinzufügen und Verweisen auf die Dag-Knoten. Die Wurzel des Dags ist der DagNode, den die Wurzel des Baums beispielsweise zurückgibt.
Offensichtlich kann die Beispielprozedur in kleinere Teile zerlegt oder als Unterklassen mit virtuellen Funktionen erstellt werden.
Zum Sortieren des Dag gehen Sie jeden DagNode von links nach rechts durch. Mit anderen Worten, folgen Sie der linken Kante von DagNodes und dann der rechten Seitenkante. Die Nummern werden umgekehrt vergeben. Mit anderen Worten, wenn Sie einen DagNode ohne untergeordnete Elemente erreichen, weisen Sie diesem Knoten die aktuelle Sortiernummer zu und erhöhen Sie die Sortiernummer, damit die Nummern beim Abwickeln der Rekursion in aufsteigender Reihenfolge zugewiesen werden.
In diesem Beispiel werden nur Bäume mit Knoten behandelt, die null oder zwei untergeordnete Elemente haben. Offensichtlich haben einige Bäume Knoten mit mehr als zwei untergeordneten Elementen, sodass die Logik immer noch dieselbe ist. Anstatt links und rechts zu berechnen, rechnen Sie von links nach rechts usw.
// 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;
}