Java assignments needed to get done, would like a quote, I can send a sample assignment once contacted

Java assignments needed to get done, would like a quote, I can send a sample assignment once contacted

Save Time On Research and Writing
Hire a Pro to Write You a 100% Plagiarism-Free Paper.
Get My Paper

For this project, write a program that stores integers in a binary search tree.
The tree should use the BTNode class which is provided.
Write a test program that generates 20 random numbers in the range of -50 to 50 to build the tree and then uses preorderPrint,
inorderPrint, and postOrderPrint to display the contents of the tree.
To get an A implement a new method for the BTNode class which creates a Java vector class to contain
the data from all the nodes in the tree. The specification for this method is provided in the BTNode file.
Details about the Java vector class are provided in Appendix D, although the only vector method you’ll use is addElement.
Also specify and implement in-order and post-order traversals and answer the question which of the
three new methods creates a vector with the entries sorted from smallest to largest?
Your test program should display the vectors created by your new methods rather than the print methods of BTNode.

// File: BTNode.java from the package edu.colorado.nodes
// Complete documentation is available from the BTNode link in:
// http://www.cs.colorado.edu/~main/docs/
package BTNode;
import java.util.Vector;
/******************************************************************************
* A BTNode< provides a node for a binary tree. Each node
* contains a piece of data (which is a reference to an E object) and references
* to a left and right child. The references to children may be null to indicate
* that there is no child. The reference stored in a node can also be null.
*
*

Limitations:

* Beyond Int.MAX_VALUE elements, treeSize, is
* wrong.
*
*

Save Time On Research and Writing
Hire a Pro to Write You a 100% Plagiarism-Free Paper.
Get My Paper
Java Source Code for this class:

*
* http://www.cs.colorado.edu/~main/edu/colorado/nodes/BTNode.java

*
* @author Michael Main
* (main@colorado.edu)
*
* @version
* Jul 22, 2005
******************************************************************************/
public class BTNode
{
// Invariant of the BTNode class:
// 1. Each node has one reference to an E Object, stored in the instance
// variable data.
// 2. The instance variables left and right are references to the node’s
// left and right children.
private E data;
private BTNode left, right;
/**
* Initialize a BTNode with a specified initial data and links
* children. Note that a child link may be the null reference,
* which indicates that the new node does not have that child.
* @param initialData
* the initial data of this new node
* @param initialLeft
* a reference to the left child of this new node–this reference may be null
* to indicate that there is no node after this new node.
* @param initialRight
* a reference to the right child of this new node–this reference may be null
* to indicate that there is no node after this new node.
*

Postcondition:

* This node contains the specified data and links to its children.
**/
public BTNode(E initialData, BTNode initialLeft, BTNode initialRight)
{
data = initialData;
left = initialLeft;
right = initialRight;
}

/**
* Accessor method to get the data from this node.
* @param – none
* @return
* the data from this node
**/
public E getData( )
{
return data;
}

/**
* Accessor method to get a reference to the left child of this node.
* @param – none
* @return
* a reference to the left child of this node (or the null reference if there
* is no left child)
**/
public BTNode getLeft( )
{
return left;
}

/**
* Accessor method to get the data from the leftmost node of the tree below
* this node.
* @param – none
* @return
* the data from the deepest node that can be reached from this node by
* following left links.
**/
public E getLeftmostData( )
{
if (left == null)
return data;
else
return left.getLeftmostData( );
}

/**
* Accessor method to get a reference to the right child of this node.
* @param – none
* @return
* a reference to the right child of this node (or the null reference if there
* is no right child)
**/
public BTNode getRight( )
{
return right;
}

/**
* Accessor method to get the data from the rightmost node of the tree below
* this node.
* @param – none
* @return
* the data from the deepest node that can be reached from this node by
* following right links.
**/
public E getRightmostData( )
{
if (left == null)
return data;
else
return left.getRightmostData( );
}

/**
* Uses an inorder traversal to print the data from each node at or below
* this node of the binary tree.
* @param – none
*

Postcondition:

* The data of this node and all its descendants have been writeen by
* System.out.println( ) using an inorder traversal.
**/
public void inorderPrint( )
{
if (left != null)
left.inorderPrint( );
System.out.println(data);
if (right != null)
right.inorderPrint( );
}

/**
* Accessor method to determine whether a node is a leaf.
* @param – none
* @return
* true (if this node is a leaf) or
* false (if this node is not a leaf.
**/
public boolean isLeaf( )
{
return (left == null) && (right == null);
}

/**
* Uses a preorder traversal to print the data from each node at or below
* this node of the binary tree.
* @param – none
*

Postcondition:

* The data of this node and all its descendants have been writeen by
* System.out.println( ) using a preorder traversal.
**/
public void preorderPrint( )
{
System.out.println(data);
if (left != null)
left.preorderPrint( );
if (right != null)
right.preorderPrint( );
}

/**
* Uses a postorder traversal to print the data from each node at or below
* this node of the binary tree.
* @param – none
*

Postcondition:

* The data of this node and all its descendants have been writeen by
* System.out.println( ) using a postorder traversal.
**/
public void postorderPrint( )
{
if (left != null)
left.postorderPrint( );
if (right != null)
right.postorderPrint( );
System.out.println(data);
}

/**
* Uses an inorder traversal to print the data from each node at or below
* this node of the binary tree, with indentations to indicate the depth
* of each node.
* @param depth
* the depth of this node (with 0 for root, 1 for the root’s
* children, and so on)(
*

Precondition:

* depth is the depth of this node.
*

Postcondition:

* The data of this node and all its descendants have been writeen by
* System.out.println( ) using an inorder traversal.
* The indentation of each line of data is four times its depth in the
* tree. A dash “–” is printed at any place where a child has no
* sibling.
**/
public void print(int depth)
{
int i;

// Print the indentation and the data from the current node:
for (i = 1; i <= depth; i++) System.out.print(" "); System.out.println(data); // Print the left subtree (or a dash if there is a right child and no left child) if (left != null) left.print(depth+1); else if (right != null) { for (i = 1; i <= depth+1; i++) System.out.print(" "); System.out.println("--"); } // Print the right subtree (or a dash if there is a left child and no left child) if (right != null) right.print(depth+1); else if (left != null) { for (i = 1; i <= depth+1; i++) System.out.print(" "); System.out.println("--"); } } /** * Remove the leftmost most node of the tree with this node as its root. * @param - none *

Postcondition:

* The tree starting at this node has had its leftmost node removed (i.e.,
* the deepest node that can be reached by following left links). The
* return value is a reference to the root of the new (smaller) tree.
* This return value could be null if the original tree had only one
* node (since that one node has now been removed).
**/
public BTNode removeLeftmost( )
{
if (left == null)
return right;
else
{
left = left.removeLeftmost( );
return this;
}
}

/**
* Remove the rightmost most node of the tree with this node as its root.
* @param – none
*

Postcondition:

* The tree starting at this node has had its rightmost node removed (i.e.,
* the deepest node that can be reached by following right links). The
* return value is a reference to the root of the new (smaller) tree.
* This return value could be null if the original tree had only one
* node (since that one node has now been removed).
**/
public BTNode removeRightmost( )
{
if (right == null)
return left;
else
{
right = right.removeRightmost( );
return this;
}
}

/**
* Modification method to set the data in this node.
* @param newData
* the new data to place in this node
*

Postcondition:

* The data of this node has been set to newData.
**/
public void setData(E newData)
{
data = newData;
}

/**
* Modification method to set the link to the left child of this node.
* @param newLeft
* a reference to the node that should appear as the left child of this node
* (or the null reference if there is no left child for this node)
*

Postcondition:

* The link to the left child of this node has been set to newLeft.
* Any other node (that used to be the left child) is no longer connected to
* this node.
**/
public void setLeft(BTNode newLeft)
{
left = newLeft;
}

/**
* Modification method to set the link to the right child of this node.
* @param newLeft
* a reference to the node that should appear as the right child of this node
* (or the null reference if there is no right child for this node)
*

Postcondition:

* The link to the right child of this node has been set to newRight.
* Any other node (that used to be the right child) is no longer connected to
* this node.
**/
public void setRight(BTNode newRight)
{
right = newRight;
}

/**
* Copy a binary tree.
* @param source
* a reference to the root of a binary tree that will be copied (which may be
* an empty tree where source is null)
* @return
* The method has made a copy of the binary tree starting at
* source. The return value is a reference to the root of the copy.
* @exception OutOfMemoryError
* Indicates that there is insufficient memory for the new tree.
**/
public static BTNode treeCopy(BTNode source)
{
BTNode leftCopy, rightCopy;
if (source == null)
return null;
else
{
leftCopy = treeCopy(source.left);
rightCopy = treeCopy(source.right);
return new BTNode(source.data, leftCopy, rightCopy);
}
}

/**
* Count the number of nodes in a binary tree.
* @param root
* a reference to the root of a binary tree (which may be
* an empty tree where source is null)
* @return
* the number of nodes in the binary tree
*

Note:

* A wrong answer occurs for trees larger than
* INT.MAX_VALUE.
**/
public static long treeSize(BTNode root)
{
if (root == null)
return 0;
else
return 1 + treeSize(root.left) + treeSize(root.right);
}
/**
* The method does a pre-order traversal of all nodes at or below this node,
* appending the data from each node to a Vector
* @param v
* the Vector that will have data appended to it
* @precondition
* The node and all its descendants have been traversed with a pre-order
* traversal, and all data has been apended to v using v.addElement
* @postcondition
* The node and all its descendants have been traversed with a pre-order
* traversal, and all data has been appended to v using v.addElement.
* @throws NullPointerException
* Indicates that v is null.
*
*/
public void preorderVector(Vector v){

}
}

// FILE: AnimalGuess.java
// This animal-guessing program illustrates the use of the binary tree node class.
import edu.colorado.nodes.BTNode;
import java.util.Scanner;
/******************************************************************************
* The AnimalGuess Java application illustrates the use of
* the binary tree node class is a small animal-guessing game.
*
*

Java Source Code for this class:

*
* http://www.cs.colorado.edu/~main/applications/Animals.java
*

*
* @author Michael Main
* (main@colorado.edu)
*
* @version
* Jul 22, 2005
******************************************************************************/
public class AnimalGuess
{
private static Scanner stdin = new Scanner(System.in);

/**
* The main method prints instructions and repeatedly plays the
* animal-guessing game. As the game is played, the taxonomy tree
* grows by learning new animals. The String argument
* (args) is not used in this implementation.
**/
public static void main(String[ ] args)
{
BTNode root;
instruct( );
root = beginningTree( );
do
play(root);
while (query(“Shall we play again?”));
System.out.println(“Thanks for teaching me a thing or two.”);
}

/**
* Print instructions for the animal-guessing game.
**/
public static void instruct( )
{
System.out.println(“Please think of an animal.”);
System.out.println(“I will ask some yes/no questions to try to figure”);
System.out.println(“out what you are.”);
}

/**
* Play one round of the animal guessing game.
* @param current
* a reference to the root node of a binary taxonomy tree that will be
* used to play the game.
*

Postcondition:

* The method has played one round of the game, and possibly
* added new information about a new animal.
* @exception java.lang.OutOfMemoryError
* Indicates that there is insufficient memory to add new
* information to the tree.
**/
public static void play(BTNode current)
{
while (!current.isLeaf( ))
{
if (query(current.getData( )))
current = current.getLeft( );
else
current = current.getRight( );
}
System.out.print(“My guess is ” + current.getData( ) + “. “);
if (!query(“Am I right?”))
learn(current);
else
System.out.println(“I knew it all along!”);
}

/**
* Construct a small taxonomy tree with four animals.
* @param – none
* @return
* a reference to the root of a taxonomy tree with the animals:
* kangaroo, mouse, trout, robin.
* @exception OutOfMemoryError
* Indicates that there is insufficient memory to create the tree.
**/
public static BTNode beginningTree( )
{
BTNode root;
BTNode child;
final String ROOT_QUESTION = “Are you a mammal?”;
final String LEFT_QUESTION = “Are you bigger than a cat?”;
final String RIGHT_QUESTION = “Do you live underwater?”;
final String ANIMAL1 = “Kangaroo”;
final String ANIMAL2 = “Mouse”;
final String ANIMAL3 = “Trout”;
final String ANIMAL4 = “Robin”;

// Create the root node with the question “Are you a mammal?”
root = new BTNode(ROOT_QUESTION, null, null);
// Create and attach the left subtree.
child = new BTNode(LEFT_QUESTION, null, null);
child.setLeft(new BTNode(ANIMAL1, null, null));
child.setRight(new BTNode(ANIMAL2, null, null));
root.setLeft(child);
// Create and attach the right subtree.
child = new BTNode(RIGHT_QUESTION, null, null);
child.setLeft(new BTNode(ANIMAL3, null, null));
child.setRight(new BTNode(ANIMAL4, null, null));
root.setRight(child);
return root;
}

/**
* Elicits information from the user to improve a binary taxonomy tree.
* @param current
* a reference to a leaf node of a binary taxonomy tree
*

Precondition:

* current is a reference to a leaf in a binary
* taxonomy tree
*

Postcondition:

* Information has been elicited from the user, and the tree has
* been improved.
* @exception OutOfMemoryError
* Indicates that there is insufficient memory to add new
* information to the tree.
**/
public static void learn(BTNode current)
// Precondition: current is a reference to a leaf in a taxonomy tree. This
// leaf contains a wrong guess that was just made.
// Postcondition: Information has been elicited from the user, and the tree
// has been improved.
{
String guessAnimal; // The animal that was just guessed
String correctAnimal; // The animal that the user was thinking of
String newQuestion; // A question to distinguish the two animals

// Set Strings for the guessed animal, correct animal and a new question.
guessAnimal = current.getData( );
System.out.println(“I give up. What are you? “);
correctAnimal = stdin.nextLine( );
System.out.println(“Please type a yes/no question that will distinguish a”);
System.out.println(correctAnimal + ” from a ” + guessAnimal + “.”);
newQuestion = stdin.nextLine( );

// Put the new question in the current node, and add two new children.
current.setData(newQuestion);
System.out.println(“As a ” + correctAnimal + “, ” + newQuestion);
if (query(“Please answer”))
{
current.setLeft(new BTNode(correctAnimal, null, null));
current.setRight(new BTNode(guessAnimal, null, null));
}
else
{
current.setLeft(new BTNode(guessAnimal, null, null));
current.setRight(new BTNode(correctAnimal, null, null));
}
}
public static boolean query(String prompt)
{
String answer;

System.out.print(prompt + ” [Y or N]: “);
answer = stdin.nextLine( ).toUpperCase( );
while (!answer.startsWith(“Y”) && !answer.startsWith(“N”))
{
System.out.print(“Invalid response. Please type Y or N: “);
answer = stdin.nextLine( ).toUpperCase( );
}
return answer.startsWith(“Y”);
}
}

// File: IntTreeBag.java from the package edu.colorado.collections
// The implementation of most methods in this file is left as a student
// exercise from Section 9.5 of “Data Structures and Other Objects Using Java”
// Check with your instructor to see whether you should put this class in
// a package. At the moment, it is declared as part of edu.colorado.collections:
package edu.colorado.collections;
import edu.colorado.nodes.IntBTNode;
/******************************************************************************
* This class is a homework assignment;
* An IntTreeBag is a collection of int numbers.
*
*

Limitations:

* Beyond Integer.MAX_VALUE elements, countOccurrences,
* and size are wrong.
*
*

Outline of Java Source Code for this class:

*
* http://www.cs.colorado.edu/~main/edu/colorado/collections/IntTreeBag.java
*

*
*

Note:

* This file contains only blank implementations (“stubs”)
* because this is a Programming Project for my students.
*
* @version
* Jan 24, 1999
*
* @see IntArrayBag
* @see IntLinkedBag
******************************************************************************/
public class IntTreeBag implements Cloneable
{
// Invariant of the IntTreeBag class:
// 1. The elements in the bag are stored in a binary search tree.
// 2. The instance variable root is a reference to the root of the
// binary search tree (or null for an empty tree).
private IntBTNode root;

/**
* Insert a new element into this bag.
* @param element
* the new element that is being inserted
*

Postcondition:

* A new copy of the element has been added to this bag.
* @exception OutOfMemoryError
* Indicates insufficient memory a new IntBTNode.
**/
public void add(int element)
{
// Implemented by student.
}

/**
* Add the contents of another bag to this bag.
* @param addend
* a bag whose contents will be added to this bag
*

Precondition:

* The parameter, addend, is not null.
*

Postcondition:

* The elements from addend have been added to this bag.
* @exception IllegalArgumentException
* Indicates that addend is null.
* @exception OutOfMemoryError
* Indicates insufficient memory to increase the size of the bag.
**/
public void addAll(IntTreeBag addend)
{
// Implemented by student.
}

/**
* Generate a copy of this bag.
* @param – none
* @return
* The return value is a copy of this bag. Subsequent changes to the
* copy will not affect the original, nor vice versa. Note that the return
* value must be type cast to an IntTreeBag before it can be used.
* @exception OutOfMemoryError
* Indicates insufficient memory for creating the clone.
**/
public Object clone( )
{ // Clone an IntTreeBag object.
// Student will replace this return statement with their own code:
return null;
}

/**
* Accessor method to count the number of occurrences of a particular element
* in this bag.
* @param target
* the element that needs to be counted
* @return
* the number of times that target occurs in this bag
**/
public int countOccurrences(int target)
{
// Student will replace this return statement with their own code:
return 0;
}

/**
* Remove one copy of a specified element from this bag.
* @param target
* the element to remove from the bag
*

Postcondition:

* If target was found in the bag, then one copy of
* target has been removed and the method returns true.
* Otherwise the bag remains unchanged and the method returns false.
**/
private boolean remove(int target)
{
// Student will replace this return statement with their own code:
return false;
}

/**
* Determine the number of elements in this bag.
* @param – none
* @return
* the number of elements in this bag
**/
public int size( )
{
return IntBTNode.treeSize(root);
}

/**
* Create a new bag that contains all the elements from two other bags.
* @param b1
* the first of two bags
* @param b2
* the second of two bags
*

Precondition:

* Neither b1 nor b2 is null.
* @return
* the union of b1 and b2
* @exception IllegalArgumentException
* Indicates that one of the arguments is null.
* @exception OutOfMemoryError
* Indicates insufficient memory for the new bag.
**/
public static IntTreeBag union(IntTreeBag b1, IntTreeBag b2)
{
// Student will replace this return statement with their own code:
return null;
}

}

Consider this code using the ArrayBag of Section 5.2 and the Location class from Chapter 2. What is the output?

Location i = new Location(0, 3);

Location j = new Location(0, 3);

b.add(i);

b.add(j);

System.out.println(b.countOccurrences(i));

A.

0

B.

1

C.

2

D.

3

Suppose that b and c are Integer objects. A typical use of the clone method looks like this:

b = (Integer) c.clone( );

Write a short clear explanation of why the (Integer) type cast is required in this typical example.

A. obj = s;

B. s = obj;

C. s = (String) obj;

D. Two or more answers are correct.

Suppose that obj is an Object variable and s is a String variable. Which of the following statements

is a correctly-compiling widening conversion? Don’t worry about possible run-time exceptions

A. obj = s;
B. s = obj;
C. s = (String) obj;
D. Two or more answers are correct.

Suppose that x and y are reference variables and a program activates x.equals(y). What occurs if x is the null reference?

A. A NullPointerException occurs

B. It always returns true.

C. It always returns false.

D. It returns true if y is also a null reference; otherwise it returns false.

Consider the implementation of the Stack using a partially-filled array.

What goes wrong if we try to store the top of the Stack at location [0] and the bottom of the Stack at the last used position of the array?

A. Both peek and pop would require linear time.

B. Both push and pop would require linear time.

C. The Stack could not be used to check balanced parentheses.

D. The Stack could not be used to evaluate postfix expressions.

Write some lines of code that declares an Integer object, using the Integer wrapper class.

Assign the value 42 to this object, then copy this value from the Integer object to an ordinary int variable.

Consider the usual algorithm for determining whether a sequence of parentheses is balanced.

What is the maximum number of parentheses that will appear on the stack AT ANY ONE TIME when the algorithm analyzes: (()(())(()))?

A. 1

B. 2

C. 3

D. 4

E. 5 or more

Consider the usual algorithm to convert an infix expression to a postfix expression.

Suppose that you have read 10 input characters during a conversion and that the

stack now contains the symbols as shown below. Suppose that you read and process

the 11th symbol of the input. What symbol is at the top of the stack in the case where

the 11th symbol is each of the choices shown?

Which of the following stack operations could result in stack underflow?

Answer

A. is_empty

B. pop

C. push

D. Two or more of the above answers

What is the value of the postfix expression 6 3 2 4 + – *:

Answer

A. Something between -15 and -100

B. Something between -5 and -15

C. Something between 5 and -5

D. Something between 5 and 15

E. Something between 15 and 100

1. An array of queues can be used to implement a priority queue, with each possible priority corresponding to its own element in the array. When is this implementation not feasible?

Answer

A.

When the number of possible priorities is huge. 

B.

When the number of possible priorities is small. 

C.

When the queues are implemented using a linked list. 

D.

When the queues are implemented with circular arrays.

Consider the implementation of the Queue using a circular array. What goes wrong if we try to keep all the items at the front of a partially-filled array (so that data[0] is always the front).

Answer

A.

B.

C.

D.

The constructor would require linear time. 

The getFront method would require linear time. 

The insert method would require linear time. 

The isEmpty method would require linear time.

If data is a circular array of CAPACITY elements, and rear is an index into that array, what is the formula for the index after rear?

Answer

A. (rear % 1) + CAPACITY

B. rear % (1 + CAPACITY)

C. (rear + 1) % CAPACITY

D. rear + (1 % CAPACITY)

In the linked-list version of the Queue class, which operations require linear time for their worst-case behavior?

Answer

A. getFront

B. insert

C. isEmpty

D. None of these operations require linear time.

Which of the following expressions evaluates to true with approximate probability equal to P? (P is double and 0 <= P <= 1).

Answer

A. Math.random() < P

B. Math.random() > P

C. Math.random() < P * 100

D. Math.random() > P * 100

Consider the following method:

 
public static void test_a(int n)

{

   System.out.println(n + ” “);
   if (n>0)
   test_a(n-2);

}

What is printed by the call test_a(4)?

A. 0 2 4

B. 0 2

C. 2 4

D. 4 2

E. 4 2 0

Consider the following method: 
public static boolean deadend()
// Postcondition: The return value is true if the direction directly
// in front is a dead end (i.e., a direction that cannot contain the
// tapestry).
{
  return inquire(“Are you facing a wall?”) || inquire(“Is your name written in front of you?”);
}
Explain why the method deadend sometimes asks 2 questions and sometimes asks only 1.

Consider the following method:

void superWriteVertical(int number)

// Postcondition: The digits of the number have been written,

// stacked vertically. If number is negative, then a negative

// sign appears on top.

{

if (number < 0)

{

System.out.println(“-“);

superWriteVertical(-number);

}

else

if (number < 10)

System.out.println(number);

else
{

superWriteVertical(number / 10);

System.out.println(number % 10);

}
}

What values of number are directly handled by the stopping case?

Suppose you are exploring a rectangular maze containing 10 rows and 20 columns. What is the maximum depth of recursion that can result if you start at the entrance and call traverse_maze?

What property of fractals lends itself to recursive thinking?

When the compiler compiles your program, how is a recursive call treated differently than a non-recursive method call?

Still stressed from student homework?
Get quality assistance from academic writers!

Order your essay today and save 25% with the discount code LAVENDER