Write a recursive buildBinaryTree method that builds a new binary tree from the contents of an array that contains integers. Use the following class definition for a node in a binary tree: class BinaryNode { int element; BinaryNode left; BinaryNode right; } Hint: Take one item from the array and insert it as the root of the tree. Divide the remaining items in half and insert one half in the right subtree and the other half in the left subtree of the root node by calling the method recursively with the relevant array indices. Note: You have to explain your method by means of
Write a recursive buildBinaryTree method that builds a new binary tree from the contents of an array
that contains integers. Use the following class definition for a node in a binary tree:
class BinaryNode
{
int element;
BinaryNode left;
BinaryNode right;
}
Hint: Take one item from the array and insert it as the root of the tree. Divide the
remaining items in half and insert one half in the right subtree and the other half in the
left subtree of the root node by calling the method recursively with the relevant array
indices.
Note: You have to explain your method by means of inline comments or by including a
pseudo-code version of this method in comments.
Write a method oddEntries that returns the number of odd integers contained in a binary
tree where the element type is int. This method is called with a link to the root node of
the tree.
Note: You have to explain your method by means of inline comments or by including a
pseudo-code version of this method in comments.
Write a Java program that:
a. Reads the integers in the text file (Input.txt) into an array.
b. Constructs a binary tree using the buildBinaryTree method from the input of the array. (Use
the given BinaryNode class but do not use the merge method to build a tree.)
c. Use the given printInOrder and printPreOrder (in the given BinaryNode class) method to
print the contents of the tree.
d. Uses the oddEntries method from question 2 to return the number of odd integers contained
in the tree
Extra resources
INPUT.TXT
1
2
3
5
8
13
21
34
55
89
BINARY CLASS
import test.BinaryNode;
// BinaryNode class; stores a node in a tree.
//
// CONSTRUCTION: with (a) no parameters, or (b) an Object,
// or (c) an Object, left child, and right child.
//
// *******************PUBLIC OPERATIONS**********************
// int size( ) --> Return size of subtree at node
// int height( ) --> Return height of subtree at node
// void printPostOrder( ) --> Print a postorder tree traversal
// void printInOrder( ) --> Print an inorder tree traversal
// void printPreOrder( ) --> Print a preorder tree traversal
// BinaryNode duplicate( )--> Return a duplicate tree
/**
* Binary node class with recursive routines to
* compute size and height.
*/
class BinaryNode
{
public BinaryNode( )
{
this( 0, null, null );
}
public BinaryNode( int theElement, BinaryNode lt, BinaryNode rt )
{
element = theElement;
left = lt;
right = rt;
}
/**
* Return the size of the binary tree rooted at t.
*/
public static int size( BinaryNode t )
{
if( t == null )
return 0;
else
return 1 + size( t.left ) + size( t.right );
}
/**
* Return the height from a node to the root node of the binary tree.
*/
public static int height( /** CODE HERE **/ )
{
/** CODE HERE **/
}
// Print tree rooted at current node using preorder traversal.
public void printPreOrder( )
{
System.out.println( element ); // Node
if( left != null )
left.printPreOrder( ); // Left
if( right != null )
right.printPreOrder( ); // Right
}
// Print tree rooted at current node using postorder traversal.
public void printPostOrder( )
{
if( left != null )
left.printPostOrder( ); // Left
if( right != null )
right.printPostOrder( ); // Right
System.out.println( element ); // Node
}
// Print tree rooted at current node using inorder traversal.
public void printInOrder( )
{
if( left != null )
left.printInOrder( ); // Left
System.out.println( element ); // Node
if( right != null )
right.printInOrder( ); // Right
}
/**
* Return a reference to a node that is the root of a
* duplicate of the binary tree rooted at the current node.
*/
public BinaryNode duplicate( )
{
BinaryNode root = new BinaryNode( element, null, null );
if( left != null ) // If there's a left subtree
root.left = left.duplicate( ); // Duplicate; attach
if( right != null ) // If there's a right subtree
root.right = right.duplicate( ); // Duplicate; attach
return root; // Return resulting tree
}
public int getElement( )
{
return element;
}
public BinaryNode getLeft( )
{
return left;
}
public BinaryNode getRight( )
{
return right;
}
public void setElement( int x )
{
element = x;
}
public void setLeft( BinaryNode t )
{
left = t;
}
public void setRight( BinaryNode t )
{
right = t;
}
private int element;
private BinaryNode left;
private BinaryNode right;
}
Trending now
This is a popular solution!
Step by step
Solved in 3 steps with 1 images
