cannot be applied to

[Dustin Schreader]

I'm getting an error on line 243 "setLeft(TreeNode) in TreeNode cannot be applied to (ExprTree)" From what I understand What is sent in the parameter for setLeft method should be of type TreeNode so am I incorrect in thinking that I can call the constructor from within the same class to create a new node of type TreeNode?

//--------------------------------------------------------------------
//
//  Laboratory 11                                       ExprTree.jshl
//
//  (Shell) Class definitions for the linked implementation of the
//  Expression Tree ADT -- including the recursive partners of the
//  public methods
//
//  The student is to complete all missing or incomplete method 
//     implementations for this class
//
//--------------------------------------------------------------------

import java.io.*;
import java.util.*;

class ExprTree
{
  // Data member
  private TreeNode root;       // Reference to the root node
  
  // Constructor
  public ExprTree ()          
  {                   
    root = null;
  }

  public ExprTree (char rootItem, TreeNode leftTree, TreeNode rightTree)          
  {                   
    root = new ExprTreeNode(rootItem, null, null);
    attachLeftSubtree(leftTree); 
    attachRightSubtree(rightTree);
  }
  
  public boolean isEmpty()
  {
   return root == null; 
  }
    
  public void makeEmpty()
  {
   root = null; 
  }
  
  public char getRootItem()
  {
    if (root == null)
    {
      System.out.println("TreeException: Empty Tree");
    }
    else
    {
      return root.getElement();
    }
  }
  
  public void setRootItem(char element) { 
    if (root != null) { 
      root.setElement(element); 
    } 
    else { 
      ExprTree root = new ExprTree(element, null, null); 
    }  // end if 
  }  // end setRootItem
  
  // 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 (String stuff) throws IOException // Build tree from prefix expression
  {                 
    /* int x = 0;
    
    if (isEmpty()) //if root is empty make operator assignment
    {
    while ( Character.isWhitespace(stuff.charAt(x))) //skip over spaces
    {  
     x++;
    } 
    
    if ( Character.isDigit(stuff.charAt(x))) //if char is digit 
    {                                        //create tree with new char
                                             //as root of tree w/ null leaf nodes
      ExprTree(stuff.charAt(x));
      x++;
      
      while ( Character.isDigit(stuff.charAt(x)) ) //if char is digit
      {                                            //create tree with new char
                                                   //as root of tree w/ null leaf node
        ExprTree(stuff.charAt(x));
        x++;
      }
      
    }
    else
          {
      ExprTree(stuff.charAt(x));
    }
    } */
    
    
  }
  
  public void expression ( )               // Output expression in infix form
  {                   
  }
  
  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
  {
    
  } 
  
  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 p;
  } 
  
  // -- Insert the definition of the rest of 
  // -- the recursive partners of the public methods below.
  // -- These recursive (helper) methods will be private.
  
  public void attachLeft(char element) { 
    if (!isEmpty() && root.getLeft() == null) { 
      // assertion: nonempty tree; no left child 
      root.setLeft(new ExprTree(element, null, null)); 
    }  // end if 
  }  // end attachLeft
    
  public void attachRight(char element) { 
    if (!isEmpty() && root.getRight() == null) { 
      // assertion: nonempty tree; no right child 
      root.setRight(new ExprTree(element, null, null)); 
    }  // end if 
  }  // end attachRight
    
  public void attachLeftSubtree(TreeNode leftTree)
  {
    if (isEmpty()) { 
      System.out.println("TreeException:  Empty tree"); 
    } 
    else if (root.getLeft() != null) { 
      // a left subtree already exists; it should have been  
      // deleted first 
      System.out.println("TreeException: Cannot overwrite left subtree"); 
    } 
    else { 
      // assertion: nonempty tree; no left child 
      root.setLeft(leftTree.root); 
      // don't want to leave multiple entry points into  
      // our tree 
      leftTree.makeEmpty();  
    }  // end if 
  }  // end attachLeftSubtree
    
  public void attachRightSubtree(TreeNode rightTree)   
  { 
    if (isEmpty()) { 
      System.out.println("TreeException:  Empty tree"); 
    } 
    else if (root.getRight() != null) { 
      // a right subtree already exists; it should have been  
      // deleted first 
      System.out.println("TreeException: Cannot overwrite right subtree"); 
    } 
    else { 
      // assertion: nonempty tree; no right child 
      root.setRight(rightTree.root); 
      // don't want to leave multiple entry points into  
      // our tree 
      rightTree.makeEmpty();  
    }  // end if 
  }  // end attachRightSubtree
  
  protected ExprTree(TreeNode rootNode) { 
    root = rootNode; 
  }  // end protected constructor
  
} // class ExprTree

[Paul Clapham]

Dustin Schreader wrote:I'm getting an error on line 243 "setLeft(TreeNode) in TreeNode cannot be applied to (ExprTree)" From what I understand What is sent in the parameter for setLeft method should be of type TreeNode so am I incorrect in thinking that I can call the constructor from within the same class to create a new node of type TreeNode?

Well, yes. You don't need me to tell you that an ExprTree isn't a TreeNode -- the compiler has already told you that. So yes, you're incorrect, calling the ExprTree constructor doesn't result in an object of type TreeNode. It results in an ExprTree object, of course.

[Anurag Malaviya]

Hi Dustin

Its hard to know the complete logic of your program with this code, it would be better if you can post the code of setLeft(TreeNode) method
or may be an explanation of your Treenode class.

what i understand from this code is that you should pass the ROOT object that you are creating to the setLeft() method instead of Exptree object.

Regards
Anurag Malaviya

[Dustin Schreader]

I was supposed to put a ExprTreeNode instead and now it works... It must be getting late... Thank you for the direction because it seemed to help.

[Harsha Smith]

if ExprTreeNode extends TreeNode, then you won't get that compilation error. As ExprTreeNode IS - A TreeNode now.

[Dustin Schreader]

I suppose I'm wondering if this is really the proper way to be doing this. ExprTreeNode is the ADT and the TreeNode is my interface. We're just learning trees and interfaces, so I guess what I should say is, should I be using ExprTreeNode's constructor or is it more correct to access the constructor through the interface TreeNode somehow. This is part of a lab and the code for the interface was already given so i'm not sure if I should be modifying it at all. Here is the 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