how to set a node on expression tree

[Dustin Schreader]

I'm trying to build an expression tree for the first time. There will be a prefix expression entered and I am thinking that I can check if there is an operator and if there is I can set the root node equal to the operator and if a number is the next character I can

root.setRight(/*"some number"*/);

and the next char will be an int as well so i'd

root.setLeft(/*"some number"*/);

but I get an error because the interface is set to take TreeNode parameter. How Do I get it to accept an int as a TreeNode? This is what I have so far.

import java.io.*;

class ExprTree  
{
  // Data member
  private TreeNode root;       // Reference to the root node
  private int single;
  boolean interior;
  char item;
  int value;
  
  TreeNode node = new ExprTreeNode(item, root, root);
  
  // Constructor
  public ExprTree ( )          
  {                   
    root.setLeft(null);
    root.setRight(null);
  }
  
  // In-lab 1 
  // Remove the surrounding comment markers when ready to implement
  /*
   public ExprTree ( ExprTree valueTree )  // Copy constructor. 
   {                   }
   public Object clone( )                  // clone the ExprTree
   {                   }
   */
  
  // Expression tree manipulation operations
  public void build ( ) throws IOException // Build tree from prefix expression
  {                 
    
    StringBuffer number = new StringBuffer(256);
    System.out.println("enter prefix expression");
    
    while ( Character.isWhitespace((char)single) ) 
    {  
      single = System.in.read(); } 
    
    if ( Character.isDigit((char)single) ) 
    {  
      
      root.setLeft(single);
      
      while ( Character.isDigit((char)single) ) 
      {  
        root.setRight((char)single);
        single = System.in.read(); 
      }
      
    }
    
    else 
    {
      root.setElement((char) single);
      single = ' ';
    }
    
  }
  
  public void expression ( )               // Output expression in infix form
  {                   
    if ( Character.isDigit((char)single) ) 
    {
      int num = (single);
      {
        
      }
    }
  }
  
  public float evaluate ( )                // Evaluate expression   
  {                   
    float resultForExpression = 0;
    char operator = ' ';
    float firstNum = 0;
    float secondNum = 0;
    
    switch ( operator )
    {
      
      case '+': 
        resultForExpression = firstNum + secondNum;
        
                
        break;
        
      case '-':
        resultForExpression = firstNum - secondNum;
        
        break;
        
      case '*':
        resultForExpression = firstNum * secondNum;
                
        break;
                
      case '/':
        if ( secondNum != 0 ) // can't divide by zero
      {

        resultForExpression = firstNum / secondNum;
                        
      }
        else // number is zero
        {
          
          System.out.println( "Cannot divide by zero" );
          System.out.println( "Program terminated" );
          System.exit( 0 ); // exit the program since you cannot calculate the value
          
        }
        
        break;
        
      default: 
        System.out.println( "Invalid operator found in the expression" );
        System.out.println( "Program terminated" );
        System.exit( 0 ); // end the program and stop evaluating the rest of the expression
        
    } // end switch
    
    System.out.println( "resultForExpression = " + resultForExpression );
    return resultForExpression;
  }
  public void clear ( )                    // Clear tree
  {
    root = null;
    right = null;
    left = null;
  } 
  
  public void showStructure ( )
    // Outputs an expression tree. The tree is output rotated counter-
    // clockwise 90 degrees from its conventional orientation using a
    // "reverse" inorder traversal. This operation is intended for testing
    // and debugging purposes only.
  {
    if ( root == null )
      System.out.println("Empty tree");
    else
    {
      System.out.println( );
      showSub(root, 1);
      System.out.println( );
    }
  }
  
  // In-lab 2
  // Remove the surrounding comment markers when ready to implement
  /* public void commute ( )          // Commute all subexpr.
   {                   }
   */
  
  // Recursive partners of the public member methods ....
  // -- insert/complete the definition of these methods here.
  
  private void showSub ( TreeNode p, int level )
    // Recursive partner of the showStructure() method. Outputs the
    // subtree whose root node is pointed to by p. Parameter level is the
    // level of this node within the expression tree.
  {
    int j;                                      // Loop counter
    TreeNode right,
      left;                                  
    
    if ( p != null )
    {
      // For efficiency, calculate right and left only once
      right = p.getRight( );
      left = p.getLeft( );
      
      showSub(right, level+1);                // Output right subtree
      for ( j = 0 ; j < level ; j++ )         // Tab over to level
        System.out.print("\t");
      System.out.print(" " + p.getElement( ));// Output element
      if ( ( left != null ) &&                // Output "connector"
          ( right != null ) )
        System.out.print("<");
      else if ( right != null )
        System.out.print("/");
      else if ( left != null )
        System.out.print("\\");
      System.out.println( );
      showSub(left, level+1);                 // Output left subtree
    }
  }
  
  private TreeNode buildSub ( TreeNode p )  throws IOException
    // Recursive partner of the build() method. Builds a subtree and
    // sets p to point to its root.
  {                   
    return node;
  } 
  
  // -- Insert the definition of the rest of 
  // -- the recursive partners of the public methods below.
  // -- These recursive (helper) methods will be private.
  
} // class ExprTree

And this is my interface

interface TreeNode               // Constants & Methods common to tree ADTs
{
    // Class Methods used by client class
    TreeNode getLeft( );                    // Return reference to left element
    TreeNode setLeft( TreeNode leftVal );   // Set reference to left element
                                            //  & return that reference
    TreeNode getRight( );                   // Return reference to right element
    TreeNode setRight( TreeNode rightVal ); // Set reference to right element
                                            //  & return that reference
    char getElement( );                     // Return the element in the current node
    char setElement(char elem);             // Set value of the element in the current node
                                            //  & return that value
} // interface TreeNode

[Dustin Schreader]

I'm getting an error that says I cannot use an int where TreeNode is supposed to be.

[Paul Clapham]

So use a TreeNode then. Your TreeNode can contain any object, can't it? Or at least you should have an implementation which can act as a leaf of the tree and contain an integer or a variable, right?

[Dustin Schreader]

So instead of making single int type i'd make it TreeNode type and the Character.isDigit((Char)single)) would still work, I get it know. I feel silly now thanks.

[Dustin Schreader]

Will I still be able to apply an operator(+, -, *, /) to the number if it is of type TreeNode?

[Dustin Schreader]

No I get an error since I'm using Character.isDigit((char)single)).

[Campbell Ritchie]

You do realise that the value of a char like '2' is not 2? A char is not a character, but a number, so you need to check whether you are passing 2, or more likely 0x32 (=50 in decimal) for that char '2'.

[Dustin Schreader]

I understand somewhat... So I need to remove (char) and Character and have single of type TreeNode so it may work?