จากซอร์สโค้ดหรือแม้กระทั่งสามมุมมองของโค้ดแอดเดรส (TAC) คุณสามารถเห็นภาพปัญหาได้อย่างง่ายดายที่หน้านี้ ...
http://cgm.cs.mcgill.ca/~hagha/topic30/topic30.html#Exptree
หากคุณไปที่ส่วนแผนภูมินิพจน์จากนั้นเลื่อนหน้าลงเล็กน้อยจะแสดง "การเรียงลำดับโทโพโลยี" ของทรีและอัลกอริทึมสำหรับวิธีประเมินนิพจน์
ดังนั้นในกรณีนี้คุณสามารถใช้ DAG เพื่อประเมินนิพจน์ซึ่งมีประโยชน์เนื่องจากโดยปกติแล้วการประเมินผลจะถูกตีความและการใช้ผู้ประเมิน DAG ดังกล่าวจะทำให้ผู้รวบรวมข้อมูลที่เรียบง่ายเร็วขึ้นในส่วนหลักเนื่องจากไม่ได้ผลักดันและโผล่ไปยังสแต็กและเนื่องจากเป็นการกำจัด นิพจน์ย่อยทั่วไป
อัลกอริทึมพื้นฐานในการคำนวณ DAG ในภาษาอียิปต์ที่ไม่ใช่ภาษาอียิปต์โบราณ (เช่นภาษาอังกฤษ) คือ:
1) ทำให้วัตถุ DAG ของคุณเป็นเช่นนั้น
คุณต้องมีรายการสดและรายการนี้มีโหนด DAG และนิพจน์ย่อย DAG ปัจจุบันทั้งหมด นิพจน์ย่อย DAG คือ DAG Node หรือเรียกอีกอย่างว่าโหนดภายใน สิ่งที่ฉันหมายถึงโดย live DAG Node คือถ้าคุณกำหนดให้กับตัวแปร X มันจะกลายเป็นสด นิพจน์ย่อยทั่วไปที่ใช้ X จะใช้อินสแตนซ์นั้น ถ้า X ถูกกำหนดให้อีกครั้ง NEW DAG NODE จะถูกสร้างและเพิ่มลงในรายการสดและ X เก่าจะถูกลบออกดังนั้นนิพจน์ย่อยถัดไปที่ใช้ X จะอ้างถึงอินสแตนซ์ใหม่และจะไม่ขัดแย้งกับนิพจน์ย่อยที่ ใช้ชื่อตัวแปรเดียวกันเท่านั้น
เมื่อคุณกำหนดให้กับตัวแปร X แล้วโดยบังเอิญโหนดนิพจน์ย่อย DAG ทั้งหมดที่อยู่ ณ จุดที่กำหนดจะกลายเป็นไม่อยู่เนื่องจากการกำหนดใหม่ทำให้ความหมายของนิพจน์ย่อยไม่ถูกต้องโดยใช้ค่าเก่า
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;
}
ดังนั้นสิ่งที่คุณทำคือเดินผ่านต้นไม้ของคุณในโค้ดของคุณเองเช่นโครงสร้างของนิพจน์ในซอร์สโค้ดเป็นต้น เรียกโหนดที่มีอยู่เช่น XNodes
ดังนั้นสำหรับแต่ละ XNode คุณต้องตัดสินใจว่าจะเพิ่มเข้าไปใน DAG อย่างไรและมีความเป็นไปได้ที่จะมีอยู่แล้วใน DAG
นี่เป็นรหัสหลอกที่ง่ายมาก ไม่ได้มีไว้สำหรับการรวบรวม
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;
}
}
นั่นคือวิธีหนึ่งในการมอง การเดินขั้นพื้นฐานของต้นไม้และเพียงแค่เพิ่มและอ้างถึงโหนด Dag เมื่อมันไป รากของ dag คืออะไรก็ตามที่ DagNode รูทของต้นไม้จะส่งกลับเช่น
เห็นได้ชัดว่าขั้นตอนตัวอย่างสามารถแบ่งออกเป็นส่วนย่อย ๆ หรือทำเป็นคลาสย่อยด้วยฟังก์ชันเสมือน
สำหรับการจัดเรียง Dag คุณจะต้องผ่าน DagNode แต่ละอันจากซ้ายไปขวา กล่าวอีกนัยหนึ่งทำตาม DagNodes ขอบด้านซ้ายมือแล้วตามด้วยขอบด้านขวามือ ตัวเลขจะถูกกำหนดกลับกัน กล่าวอีกนัยหนึ่งเมื่อคุณไปถึง DagNode โดยไม่มีลูกให้กำหนด Node นั้นให้เป็นหมายเลขการเรียงลำดับปัจจุบันและเพิ่มหมายเลขการเรียงลำดับดังนั้นเมื่อการเรียกซ้ำคลายตัวเลขที่ได้รับมอบหมายตามลำดับที่เพิ่มขึ้น
ตัวอย่างนี้จัดการเฉพาะต้นไม้ที่มีโหนดที่มีลูกศูนย์หรือสองลูก เห็นได้ชัดว่าต้นไม้บางต้นมีโหนดที่มีลูกมากกว่าสองลูกดังนั้นตรรกะจึงยังคงเหมือนเดิม แทนที่จะคำนวณซ้ายและขวาให้คำนวณจากซ้ายไปขวาเป็นต้น ...
// 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;
}