Từ góc độ mã nguồn hoặc thậm chí ba địa chỉ (TAC), bạn có thể hình dung vấn đề thực sự dễ dàng tại trang này ...
http://cgm.cs.mcgill.ca/~hagha/topic30/topic30.html#Exptree
Nếu bạn đi đến phần cây biểu thức và sau đó trang xuống một chút, nó sẽ hiển thị "sắp xếp cấu trúc liên kết" của cây và thuật toán về cách đánh giá biểu thức.
Vì vậy, trong trường hợp đó, bạn có thể sử dụng DAG để đánh giá các biểu thức, điều này rất tiện lợi vì đánh giá thường được diễn giải và việc sử dụng bộ đánh giá DAG như vậy sẽ làm cho các trình thông dịch đơn giản nhanh hơn trong chính vì nó không đẩy và xuất hiện vào một ngăn xếp và cũng vì nó đang loại bỏ biểu thức phụ thông thường.
Thuật toán cơ bản để tính toán DAG trong tiếng Ai Cập cổ đại (tức là tiếng Anh) là:
1) Làm cho đối tượng DAG của bạn như vậy
Bạn cần một danh sách trực tiếp và danh sách này chứa tất cả các nút DAG trực tiếp hiện tại và các biểu thức con DAG. Biểu thức con DAG là một Nút DAG, hoặc bạn cũng có thể gọi nó là một nút bên trong. Ý tôi muốn nói về Node DAG trực tiếp là nếu bạn gán cho một biến X thì nó sẽ hoạt động. Một biểu thức con phổ biến sau đó sử dụng X sử dụng trường hợp đó. Nếu X được gán lại thì một DAG NODE MỚI được tạo và thêm vào danh sách trực tiếp và X cũ bị xóa vì vậy biểu thức con tiếp theo sử dụng X sẽ tham chiếu đến phiên bản mới và do đó sẽ không xung đột với các biểu thức phụ chỉ sử dụng cùng một tên biến.
Khi bạn gán cho một biến X, thì ngẫu nhiên tất cả các nút biểu thức con DAG đang tồn tại tại điểm gán trở thành không tồn tại, vì phép gán mới làm mất hiệu lực ý nghĩa của các biểu thức phụ sử dụng giá trị cũ.
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;
}
Vì vậy, những gì bạn làm là đi qua cây của bạn trong mã của riêng bạn, chẳng hạn như một cây biểu thức trong mã nguồn chẳng hạn. Gọi các nút hiện có là XNodes chẳng hạn.
Vì vậy, đối với mỗi XNode, bạn cần quyết định cách thêm nó vào DAG và có khả năng nó đã có trong DAG.
Đây là mã giả rất đơn giản. Không dùng để biên dịch.
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;
}
}
Vì vậy, đó là một cách để xem xét nó. Một bước đi cơ bản của cây và chỉ cần thêm vào và tham chiếu đến các nút Dag khi nó hoạt động. Gốc của dag là bất kỳ DagNode nào mà gốc của cây trả về chẳng hạn.
Rõ ràng là thủ tục ví dụ có thể được chia thành các phần nhỏ hơn hoặc được tạo thành các lớp con với các hàm ảo.
Đối với việc phân loại Dag, bạn đi qua từng DagNode từ trái sang phải. Nói cách khác, theo cạnh bên trái của DagNodes, và sau đó là cạnh bên phải. Các con số được gán ngược lại. Nói cách khác, khi bạn đến một DagNode không có con nào, hãy gán cho Node đó số sắp xếp hiện tại và tăng số sắp xếp, để đệ quy giải nén các số được gán theo thứ tự tăng dần.
Ví dụ này chỉ xử lý các cây có nút không có hoặc hai nút con. Rõ ràng là một số cây có các nút với nhiều hơn hai con nên logic vẫn giống nhau. Thay vì tính toán trái và phải, hãy tính toán từ trái sang phải, v.v.
// 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;
}