Question

python!

Input:
For this first part you will be given a set of strings that represents a fully parenthesized infix expression that eventually (next assignment) be differentiated. The expression will be composed of single digit integers ("A"-"E"), the variable "X", parenthesis "(" and ")', and the binary operators +, -, *, /, and ^ (exponentiation). No spaces.

Process:
Generate a binary parse tree from the given input.

Output:
(1) Echo print the input string.
(2) Print out the parse tree using an in-order traversal.

This is the first of three assignments where you will develop a program that symbolically differentiates and arithmetic expression. You do not need to know how differentiation works to write any of the programs. You will not be doing any computations. You will be given a set of rules to apply.

Answer 1

Expression Tree

Expression tree is a binary tree in which each internal node corresponds to operator and each leaf node corresponds to operand so for example expression tree for a + ((b+c)*d) would be:

we are using only rules of binary tree.

Algorithm used for this inorder traversal.

Let t be the expression tree
If  t is not null then
      If t.value is operand then  
                Return  t.value
      A = solve(t.left)
      B = solve(t.right)
      // differentiate applies operator 't.value' 
      // on A and B, and returns value
      Return result(A, B, t.value)

Now For constructing expression tree we use a stack. We loop through input expression and do following for every character.
1) If character is operand push that into stack
2) If character is operator pop two values from stack make them its child and push current node again.
At the end only element of stack will be root of expression tree.

program in python

# Python program for expression tree

  

# An expression tree node

class Et:

  

    # Constructor to create a node

    def __init__(self , value):

        self.value = value

        self.left = None

        self.right = None

  

# A utility function to check if 'c'

# is an operator

def isOperator(c):

    if (c == '+' or c == '-' or c == '*'

        or c == '/' or c == '^'):

        return True

    else:

        return False

  

# A utility function to do inorder traversal

def inorder(t):

    if t is not None:

        inorder(t.left)

        print t.value,

        inorder(t.right)

  

# Returns root of constructed tree for

# given postfix expression

def constructTree(postfix):

    stack = []

  

    # Traverse through every character of input expression

    for char in postfix :

        # if operand, simply push into stack

        if not isOperator(char):

            t = Et(char)

            stack.append(t)

        # Operator

        else:

   # Pop two top nodes

            t = Et(char)

            t1 = stack.pop()

            t2 = stack.pop()

# make them children

            t.right = t1

            t.left = t2

              

            # Add this subexpression to stack

            stack.append(t)

  

    # Only element will be the root of expression tree

    t = stack.pop()

    return t

# Driver program to test above

postfix = "ab+ef*g*-"

r = constructTree(postfix)

print "Infix expression is"

inorder(r)