Dari perspektif kode sumber atau bahkan kode tiga alamat (TAC), Anda dapat memvisualisasikan masalah dengan sangat mudah di halaman ini ...
http://cgm.cs.mcgill.ca/~hagha/topic30/topic30.html#Exptree
Jika Anda pergi ke bagian pohon ekspresi, dan kemudian sedikit turun halaman itu menunjukkan "pengurutan topologi" dari pohon tersebut, dan algoritma untuk bagaimana mengevaluasi ekspresi.
Jadi dalam hal ini Anda dapat menggunakan DAG untuk mengevaluasi ekspresi, yang berguna karena evaluasi biasanya diinterpretasikan dan menggunakan DAG evaluator akan membuat penyusup sederhana lebih cepat pada prinsipnya karena tidak mendorong dan muncul ke tumpukan dan juga karena menghilangkan sub-ekspresi umum.
Algoritme dasar untuk menghitung DAG di Mesir kuno (yaitu bahasa Inggris) adalah ini:
1) Buat objek DAG Anda seperti itu
Anda memerlukan daftar langsung dan daftar ini menampung semua node DAG langsung dan sub-ekspresi DAG. Sub ekspresi DAG adalah Node DAG, atau Anda juga bisa menyebutnya node internal. Yang saya maksud dengan Node DAG langsung adalah jika Anda menetapkan ke variabel X maka variabel itu menjadi langsung. Sub-ekspresi umum yang kemudian menggunakan X menggunakan contoh itu. Jika X ditetapkan ke lagi maka NODE DAG BARU dibuat dan ditambahkan ke daftar langsung dan X lama dihapus sehingga sub-ekspresi berikutnya yang menggunakan X akan merujuk ke contoh baru dan dengan demikian tidak akan bertentangan dengan sub-ekspresi yang cukup gunakan nama variabel yang sama.
Setelah Anda menetapkan ke variabel X, secara kebetulan semua node sub-ekspresi DAG yang berada pada titik penugasan menjadi tidak aktif, karena tugas baru membatalkan arti sub-ekspresi menggunakan nilai lama.
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;
}
Jadi yang Anda lakukan adalah berjalan melalui pohon Anda dalam kode Anda sendiri, seperti pohon ekspresi dalam kode sumber misalnya. Panggil node yang ada XNodes misalnya.
Jadi untuk setiap XNode Anda perlu memutuskan cara menambahkannya ke DAG, dan ada kemungkinan sudah ada di DAG.
Ini adalah kode pseudo yang sangat sederhana. Tidak dimaksudkan untuk kompilasi.
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;
}
}
Jadi itulah salah satu cara untuk melihatnya. Penjelajahan dasar dari pohon dan hanya menambahkan dan merujuk ke simpul Dag saat berjalan. Akar dag adalah apa pun DagNode yang dikembalikan akar pohon misalnya.
Tentunya prosedur contoh dapat dipecah menjadi bagian-bagian yang lebih kecil atau dibuat sebagai sub-kelas dengan fungsi virtual.
Sedangkan untuk menyortir Dag, Anda melewati setiap DagNode dari kiri ke kanan. Dengan kata lain ikuti tepi kiri DagNodes, lalu tepi sisi kanan. Nomor-nomor tersebut ditetapkan secara terbalik. Dengan kata lain ketika Anda mencapai DagNode tanpa anak, tetapkan Node tersebut nomor pengurutan saat ini dan tambahkan nomor pengurutan, sehingga rekursi melepaskan nomor yang ditetapkan dalam urutan yang meningkat.
Contoh ini hanya menangani pohon dengan node yang memiliki nol atau dua turunan. Jelas beberapa pohon memiliki node dengan lebih dari dua anak sehingga logikanya masih sama. Alih-alih menghitung kiri dan kanan, hitung dari kiri ke kanan dll ...
// 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;
}