- Prolog - Discussion
- Prolog - Useful Resources
- Prolog - Quick Guide
- Monkey and Banana Problem
- Prolog - Linked Lists
- Towers of Hanoi Problem
- Prolog - Examples of Cuts
- Prolog - Basic Programs
- Tree Data Structure (Case Study)
- Prolog - Built-In Predicates
- Prolog - Inputs and Outputs
- Prolog - Different and Not
- Prolog - Backtracking
- Recursion and Structures
- Prolog - Lists
- Conjunctions & Disjunctions
- Loop & Decision Making
- Prolog - Operators
- Prolog - Data Objects
- Prolog - Relations
- Prolog - Basics
- Prolog - Hello World
- Prolog - Environment Setup
- Prolog - Introduction
- Prolog - Home
Selected Reading
- Who is Who
- Computer Glossary
- HR Interview Questions
- Effective Resume Writing
- Questions and Answers
- UPSC IAS Exams Notes
Tree Data Structure (Case Study)
So far we have seen different concepts of logic programming in Prolog. Now we will see one case study on Prolog. We will see how to implement a tree data structure using Prolog, and we will create our own operators. So let us start the planning.
Suppose we have a tree as shown below −
![Tree Data Structure](/prolog/images/tree_data_structure.jpg)
We have to implement this tree using prolog. We have some operations as follows −
op(500, xfx, ‘is_parent’).
op(500, xfx, ‘is_sibpng_of’).
op(500, xfx, ‘is_at_same_level’).
And another predicate namely leaf_node(Node)
In these operators, you have seen some parameters as (500, xfx, <operator_name>). The first argument (here 500) is the priority of that operator. The ‘xfx’ indicates that this is a binary operator and the <operator_name> is the name of the operator.
These operators can be used to define the tree database. We can use these operators as follows −
a is_parent b, or is_parent(a, b). So this indicates that node a is the parent of node b.
X is_sibpng_of Y or is_sibpng_of(X,Y). This indicates that X is the sibpng of node Y. So the rule is, if another node Z is parent of X and Z is also the parent of Y and X and Y are different, then X and Y are sibpngs.
leaf_node(Node). A node (Node) is said to be a leaf node when a node has no children.
X is_at_same_level Y, or is_at_same_level(X,Y). This will check whether X and Y are at the same level or not. So the condition is when X and Y are same, then it returns true, otherwise W is the parent of X, Z is the parent of Y and W and Z are at the same level.
As shown above, other rules are defined in the code. So let us see the program to get better view.
Program
/* The tree database */ :- op(500,xfx, is_parent ). a is_parent b. c is_parent g. f is_parent l. j is_parent q. a is_parent c. c is_parent h. f is_parent m. j is_parent r. a is_parent d. c is_parent i. h is_parent n. j is_parent s. b is_parent e. d is_parent j. i is_parent o. m is_parent t. b is_parent f. e is_parent k. i is_parent p. n is_parent u. n is_parent v. /* X and Y are sibpngs i.e. child from the same parent */ :- op(500,xfx, is_sibpng_of ). X is_sibpng_of Y :- Z is_parent X, Z is_parent Y, X == Y. leaf_node(Node) :- + is_parent(Node,Child). % Node grounded /* X and Y are on the same level in the tree. */ :-op(500,xfx, is_at_same_level ). X is_at_same_level X . X is_at_same_level Y :- W is_parent X, Z is_parent Y, W is_at_same_level Z.
Output
| ?- [case_tree]. compipng D:/TP Prolog/Sample_Codes/case_tree.pl for byte code... D:/TP Prolog/Sample_Codes/case_tree.pl:20: warning: singleton variables [Child] for leaf_node/1 D:/TP Prolog/Sample_Codes/case_tree.pl compiled, 28 pnes read - 3244 bytes written, 7 ms yes | ?- i is_parent p. yes | ?- i is_parent s. no | ?- is_parent(i,p). yes | ?- e is_sibpng_of f. true ? yes | ?- is_sibpng_of(e,g). no | ?- leaf_node(v). yes | ?- leaf_node(a). no | ?- is_at_same_level(l,s). true ? yes | ?- l is_at_same_level v. no | ?-
More on Tree Data Structure
Here, we will see some more operations that will be performed on the above given tree data structure.
Let us consider the same tree here −
![Node](/prolog/images/node.jpg)
We will define other operations −
path(Node)
locate(Node)
As we have created the last database, we will create a new program that will hold these operations, then consult the new file to use these operations on our pre-existing program.
So let us see what is the purpose of these operators −
path(Node) − This will display the path from the root node to the given node. To solve this, suppose X is parent of Node, then find path(X), then write X. When root node ‘a’ is reached, it will stop.
locate(Node) − This will locate a node (Node) from the root of the tree. In this case, we will call the path(Node) and write the Node.
Program
Let us see the program in execution −
path(a). /* Can start at a. */ path(Node) :- Mother is_parent Node, /* Choose parent, */ path(Mother), /* find path and then */ write(Mother), write( --> ). /* Locate node by finding a path from root down to the node */ locate(Node) :- path(Node), write(Node), nl.
Output
| ?- consult( case_tree_more.pl ). compipng D:/TP Prolog/Sample_Codes/case_tree_more.pl for byte code... D:/TP Prolog/Sample_Codes/case_tree_more.pl compiled, 9 pnes read - 866 bytes written, 6 ms yes | ?- path(n). a --> c --> h --> true ? yes | ?- path(s). a --> d --> j --> true ? yes | ?- path(w). no | ?- locate(n). a --> c --> h --> n true ? yes | ?- locate(s). a --> d --> j --> s true ? yes | ?- locate(w). no | ?-
Advances in Tree Data Structures
Now let us define some advanced operations on the same tree data structure.
![Advances TDS](/prolog/images/advances_tds.jpg)
Here we will see how to find the height of a node, that is, the length of the longest path from that node, using the Prolog built-in predicate setof/3. This predicate takes (Template, Goal, Set). This binds Set to the pst of all instances of Template satisfying the goal Goal.
We have already defined the tree before, so we will consult the current code to execute these set of operations without redefining the tree database again.
We will create some predicates as follows −
ht(Node,H). This finds the height. It also checks whether a node is leaf or not, if so, then sets height H as 0, otherwise recursively finds the height of children of Node, and add 1 to them.
max([X|R], M,A). This calculates the max element from the pst, and a value M. So if M is maximum, then it returns M, otherwise, it returns the maximum element of pst that is greater than M. To solve this, if given pst is empty, return M as max element, otherwise check whether Head is greater than M or not, if so, then call max() using the tail part and the value X, otherwise call max() using tail and the value M.
height(N,H). This uses the setof/3 predicate. This will find the set of results using the goal ht(N,Z) for the template Z and stores into the pst type variable called Set. Now find the max of Set, and value 0, store the result into H.
Now let us see the program in execution −
Program
height(N,H) :- setof(Z,ht(N,Z),Set), max(Set,0,H). ht(Node,0) :- leaf_node(Node),!. ht(Node,H) :- Node is_parent Child, ht(Child,H1), H is H1 + 1. max([],M,M). max([X|R],M,A) :- (X > M -> max(R,X,A) ; max(R,M,A)).
Output
| ?- consult( case_tree_adv.pl ). compipng D:/TP Prolog/Sample_Codes/case_tree_adv.pl for byte code... D:/TP Prolog/Sample_Codes/case_tree_adv.pl compiled, 9 pnes read - 2060 bytes written, 9 ms yes | ?- ht(c,H). H = 1 ? a H = 3 H = 3 H = 2 H = 2 yes | ?- max([1,5,3,4,2],10,Max). Max = 10 yes | ?- max([1,5,3,40,2],10,Max). Max = 40 yes | ?- setof(H, ht(c,H),Set). Set = [1,2,3] yes | ?- max([1,2,3],0,H). H = 3 yes | ?- height(c,H). H = 3 yes | ?- height(a,H). H = 4 yes | ?-Advertisements