Please read the comment ins codeExpressionTree.java-------------.pdf

Please read the comment ins code
ExpressionTree.java
----------------------------------
/**
* This is the class for Expression Tree.
* Used to create Expression Tree and Evaluate it
*/
/**
* Following logic is used to construct a Tree
* Here we use stack for Preparing Tree
* Loop through given Expression String
* If Character is Operand , Create node and push to stack
* If Character is Operator then
* 1)Create Node for Operator
* 2)Pop 2 nodes from Stack and Made
* OpretorNode--> left == first node pop
* OpretorNode--> right == second node pop
* At the end of creation of Expression Tree, Stack have only one node , which is root of
Expression tree
*/
/** Class ExpressionTree **/
class ExpressionTree
{
/** class TreeNode
* Stored Character ==> Digit(0..9) or a Operator +,-,*,/
* Left Node and Right Node
*
* **/
class TreeNode
{
char data;
TreeNode left, right;
/** constructor **/

public TreeNode(char data)
{
this.data = data;
this.left = null;
this.right = null;
}
}
/** class StackNode **/
class StackNode
{
TreeNode treeNode;
StackNode next;
/** constructor **/
public StackNode(TreeNode treeNode)
{
this.treeNode = treeNode;
next = null;
}
}
private static StackNode top;
/** constructor
* Constructor takes input string like "+-+7*935*82*625"
* Input should be in Prefix notation
* **/
public ExpressionTree(String expression)
{
top = null;
//Call Method for prepare expression tree
buildTree(expression);
}
/** function to clear tree **/
public void clear()
{
top = null;
}
/** function to push a node **/

private void push(TreeNode ptr)
{
if (top == null)
top = new StackNode(ptr);
else
{
StackNode nptr = new StackNode(ptr);
nptr.next = top;
top = nptr;
}
}
/** function to pop a node
* When it find operator pop 2 elements from Stack
*
* **/
private TreeNode pop()
{
if (top == null)
throw new RuntimeException("Underflow");
else
{
TreeNode ptr = top.treeNode;
top = top.next;
return ptr;
}
}
/** function to get top node **/
private TreeNode peek()
{
return top.treeNode;
}
/** function to insert character **/
private void insert(char val)
{
try
{

//If Operand , Create node and push to Stack
if (isDigit(val))
{
TreeNode nptr = new TreeNode(val);
push(nptr);
}
//If Operator , Create node and popup 2 elements and make them its right and left
else if (isOperator(val))
{
nptr.left = pop();
nptr.right = pop();
push(nptr);
}
}
catch (Exception e)
{
System.out.println("Invalid Expression");
}
}
/** function to check if digit **/
private boolean isDigit(char ch)
{
return ch >= '0' && ch <= '9';
}
/** function to check if operator **/
private boolean isOperator(char ch)
{
return ch == '+' || ch == '-' || ch == '*' || ch == '/';
}
/** function to convert character to digit **/
private int toDigit(char ch)
{
return ch - '0';
}
/** function to build tree from input */

public void buildTree(String eqn)
{
for (int i = eqn.length() - 1; i >= 0; i--)
insert(eqn.charAt(i));
}
/** function to evaluate tree */
public double evaluate()
{
return evaluate(peek());
}
/** function to evaluate tree
*
* */
public double evaluate(TreeNode ptr)
{
if (ptr.left == null && ptr.right == null)
return toDigit(ptr.data);
else
{
double result = 0.0;
double left = evaluate(ptr.left);
double right = evaluate(ptr.right);
char operator = ptr.data;
switch (operator)
{
case '+' : result = left + right; break;
case '-' : result = left - right; break;
case '*' : result = left * right; break;
case '/' : result = left / right; break;
default : result = left + right; break;
}
return result;
}
}
/** function to get postfix expression */
public void postfix()

{
postOrder(peek());
}
/** post order traversal */
private void postOrder(TreeNode ptr)
{
if (ptr != null)
{
postOrder(ptr.left);
postOrder(ptr.right);
System.out.print(ptr.data);
}
}
/** function to get infix expression */
public void infix()
{
inOrder(peek());
}
/** in order traversal */
private void inOrder(TreeNode ptr)
{
if (ptr != null)
{
inOrder(ptr.left);
inOrder(ptr.right);
}
}
/** function to get prefix expression */
public void prefix()
{
preOrder(peek());
}
/** pre order traversal */
private void preOrder(TreeNode ptr)
{

if (ptr != null)
{
preOrder(ptr.left);
preOrder(ptr.right);
}
}
}
ExpressionTreeTest.java , class to test
------------------------------------------------------------
import java.util.Scanner;
/** class ExpressionTreeTest **/
public class ExpressionTreeTest
{
public static void main(String[] args)
{
Scanner scan = new Scanner(System.in);
System.out.println("Expression Tree Test");
System.out.println(" Enter equation in prefix form");
/** make object of ExpressionTree **/
ExpressionTree et = new ExpressionTree(scan.next());
System.out.print(" Prefix : ");
et.prefix();
System.out.print(" Infix : ");
et.infix();
System.out.print(" Postfix : ");
et.postfix();
System.out.println(" Evaluated Result : "+ et.evaluate());
}
}
Solution

Please read the comment ins code
ExpressionTree.java
----------------------------------
/**
* This is the class for Expression Tree.
* Used to create Expression Tree and Evaluate it
*/
/**
* Following logic is used to construct a Tree
* Here we use stack for Preparing Tree
* Loop through given Expression String
* If Character is Operand , Create node and push to stack
* If Character is Operator then
* 1)Create Node for Operator
* 2)Pop 2 nodes from Stack and Made
* OpretorNode--> left == first node pop
* OpretorNode--> right == second node pop
* At the end of creation of Expression Tree, Stack have only one node , which is root of
Expression tree
*/
/** Class ExpressionTree **/
class ExpressionTree
{
/** class TreeNode
* Stored Character ==> Digit(0..9) or a Operator +,-,*,/
* Left Node and Right Node
*
* **/
class TreeNode
{
char data;
TreeNode left, right;
/** constructor **/
public TreeNode(char data)

{
this.data = data;
this.left = null;
this.right = null;
}
}
/** class StackNode **/
class StackNode
{
TreeNode treeNode;
StackNode next;
/** constructor **/
public StackNode(TreeNode treeNode)
{
this.treeNode = treeNode;
next = null;
}
}
private static StackNode top;
/** constructor
* Constructor takes input string like "+-+7*935*82*625"
* Input should be in Prefix notation
* **/
public ExpressionTree(String expression)
{
top = null;
//Call Method for prepare expression tree
buildTree(expression);
}
/** function to clear tree **/
public void clear()
{
top = null;
}
/** function to push a node **/
private void push(TreeNode ptr)

{
if (top == null)
top = new StackNode(ptr);
else
{
StackNode nptr = new StackNode(ptr);
nptr.next = top;
top = nptr;
}
}
/** function to pop a node
* When it find operator pop 2 elements from Stack
*
* **/
private TreeNode pop()
{
if (top == null)
throw new RuntimeException("Underflow");
else
{
TreeNode ptr = top.treeNode;
top = top.next;
return ptr;
}
}
/** function to get top node **/
private TreeNode peek()
{
return top.treeNode;
}
/** function to insert character **/
private void insert(char val)
{
try
{
//If Operand , Create node and push to Stack

if (isDigit(val))
{
push(nptr);
}
//If Operator , Create node and popup 2 elements and make them its right and left
else if (isOperator(val))
{
nptr.left = pop();
nptr.right = pop();
push(nptr);
}
}
catch (Exception e)
{
System.out.println("Invalid Expression");
}
}
/** function to check if digit **/
private boolean isDigit(char ch)
{
return ch >= '0' && ch <= '9';
}
/** function to check if operator **/
private boolean isOperator(char ch)
{
return ch == '+' || ch == '-' || ch == '*' || ch == '/';
}
/** function to convert character to digit **/
private int toDigit(char ch)
{
return ch - '0';
}
/** function to build tree from input */
public void buildTree(String eqn)

{
for (int i = eqn.length() - 1; i >= 0; i--)
insert(eqn.charAt(i));
}
/** function to evaluate tree */
public double evaluate()
{
return evaluate(peek());
}
/** function to evaluate tree
*
* */
public double evaluate(TreeNode ptr)
{
if (ptr.left == null && ptr.right == null)
return toDigit(ptr.data);
else
{
double result = 0.0;
double left = evaluate(ptr.left);
double right = evaluate(ptr.right);
char operator = ptr.data;
switch (operator)
{
case '+' : result = left + right; break;
case '-' : result = left - right; break;
case '*' : result = left * right; break;
case '/' : result = left / right; break;
default : result = left + right; break;
}
return result;
}
}
/** function to get postfix expression */
public void postfix()
{

postOrder(peek());
}
/** post order traversal */
private void postOrder(TreeNode ptr)
{
if (ptr != null)
{
postOrder(ptr.left);
postOrder(ptr.right);
}
}
/** function to get infix expression */
public void infix()
{
inOrder(peek());
}
/** in order traversal */
private void inOrder(TreeNode ptr)
{
if (ptr != null)
{
inOrder(ptr.left);
inOrder(ptr.right);
}
}
/** function to get prefix expression */
public void prefix()
{
preOrder(peek());
}
/** pre order traversal */
private void preOrder(TreeNode ptr)
{
if (ptr != null)

{
preOrder(ptr.left);
preOrder(ptr.right);
}
}
}
ExpressionTreeTest.java , class to test
------------------------------------------------------------
import java.util.Scanner;
/** class ExpressionTreeTest **/
public class ExpressionTreeTest
{
public static void main(String[] args)
{
Scanner scan = new Scanner(System.in);
System.out.println("Expression Tree Test");
System.out.println(" Enter equation in prefix form");
/** make object of ExpressionTree **/
ExpressionTree et = new ExpressionTree(scan.next());
System.out.print(" Prefix : ");
et.prefix();
System.out.print(" Infix : ");
et.infix();
System.out.print(" Postfix : ");
et.postfix();
System.out.println(" Evaluated Result : "+ et.evaluate());
}
}

Please read the comment ins codeExpressionTree.java-------------.pdf

Recommended

More Related Content

Similar to Please read the comment ins codeExpressionTree.java-------------.pdf (20)

More from shanki7 (20)

Recently uploaded (20)

Please read the comment ins codeExpressionTree.java-------------.pdf