For this project, write a program that stores integers in a binary.docx

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 <CODE>BTNode<<E></CODE> 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.
*
* <dl><dt>Limitations: <dd>

* Beyond <CODE>Int.MAX_VALUE</CODE> elements,
<CODE>treeSize</CODE>, is
* wrong.
*
* <dt>Java Source Code for this class:<dd>
* <A HREF="../../../../edu/colorado/nodes/BTNode.java">
*
http://www.cs.colorado.edu/~main/edu/colorado/nodes/BTNode.
java </A>
*
* @author Michael Main
* <A HREF="mailto:[email protected]"> ([email protected])
</A>
*
* @version
* Jul 22, 2005
*****************************************************
*************************/
public class BTNode<E>
{

// Invariant of the BTNode<E> 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<E> left, right;
/**
* Initialize a <CODE>BTNode</CODE> 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 <CODE>initialData</CODE>
* the initial data of this new node
* @param <CODE>initialLeft</CODE>
* 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 <CODE>initialRight</CODE>
* 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.
* <dt>Postcondition:<dd>
* This node contains the specified data and links to its
children.
**/
public BTNode(E initialData, BTNode<E> initialLeft,
BTNode<E> 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<E> 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<E> 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
* The data of this node and all its descendants have been
writeen by
* <CODE>System.out.println( )</CODE> 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
* <CODE>true</CODE> (if this node is a leaf) or
* <CODE>false</CODE> (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
* @param - none
writeen by
* <CODE>System.out.println( )</CODE> using a preorder
traversal.
**/
public void preorderPrint( )
{
if (left != null)
left.preorderPrint( );
if (right != null)
right.preorderPrint( );
}

/**
* Uses a postorder traversal to print the data from each node
at or below
* @param - none
writeen by
* <CODE>System.out.println( )</CODE> using a postorder
traversal.
**/
public void postorderPrint( )
{
if (left != null)
left.postorderPrint( );
if (right != null)
right.postorderPrint( );
}

/**
* 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 <CODE>depth</CODE>
* the depth of this node (with 0 for root, 1 for the root's
* children, and so on)(
* <dt>Precondition:<dd>
* <CODE>depth</CODE> is the depth of this node.
writeen by
* <CODE>System.out.println( )</CODE> 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(" ");
// 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.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.println("--");
}
}
/**

* Remove the leftmost most node of the tree with this node as
its root.
* @param - none
* 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<E> 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
* 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<E> removeRightmost( )
{
if (right == null)
return left;
else
{
right = right.removeRightmost( );
return this;
}
}
/**
* Modification method to set the data in this node.
* @param <CODE>newData</CODE>
* the new data to place in this node
* The data of this node has been set to
<CODE>newData</CODE>.
**/

public void setData(E newData)
{
data = newData;
}
/**
* Modification method to set the link to the left child of this
node.
* @param <CODE>newLeft</CODE>
* 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)
* The link to the left child of this node has been set to
<CODE>newLeft</CODE>.
* Any other node (that used to be the left child) is no longer
connected to
* this node.
**/

public void setLeft(BTNode<E> newLeft)
{
left = newLeft;
}
/**
* Modification method to set the link to the right child of this
node.
* @param <CODE>newLeft</CODE>
* 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)
* The link to the right child of this node has been set to
<CODE>newRight</CODE>.
* Any other node (that used to be the right child) is no
longer connected to
* this node.

**/
public void setRight(BTNode<E> newRight)
{
right = newRight;
}
/**
* Copy a binary tree.
* @param <CODE>source</CODE>
* a reference to the root of a binary tree that will be copied
(which may be
* an empty tree where <CODE>source</CODE> is null)
* @return
* The method has made a copy of the binary tree starting at
* <CODE>source</CODE>. 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 <E> BTNode<E> treeCopy(BTNode<E> source)
{
BTNode<E> leftCopy, rightCopy;
if (source == null)
return null;
else
{
leftCopy = treeCopy(source.left);
rightCopy = treeCopy(source.right);
return new BTNode<E>(source.data, leftCopy,
rightCopy);
}
}
/**

* Count the number of nodes in a binary tree.
* @param <CODE>root</CODE>
* a reference to the root of a binary tree (which may be
* an empty tree where <CODE>source</CODE> is null)
* @return
* the number of nodes in the binary tree
* <dt>Note:<dd>
* A wrong answer occurs for trees larger than
* <CODE>INT.MAX_VALUE</CODE>.
**/
public static <E> long treeSize(BTNode<E> 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<E> 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 <CODE>AnimalGuess</CODE> Java application
illustrates the use of
* the binary tree node class is a small animal-guessing game.
*
* <dt>Java Source Code for this class:<dd>
* <A HREF="../applications/Animals.java">
* http://www.cs.colorado.edu/~main/applications/Animals.java
* </A>
*
* @author Michael Main
* <A HREF="mailto:[email protected]"> ([email protected])
</A>
*
* @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
<CODE>String</CODE> argument
* (<CODE>args</CODE>) is not used in this implementation.
**/
public static void main(String[ ] args)
{
BTNode<String> 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 <CODE>current</CODE>
* a reference to the root node of a binary taxonomy tree that
will be
* used to play the game.
* 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<String> 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.
* Indicates that there is insufficient memory to create the
tree.
**/
public static BTNode<String> beginningTree( )
{
BTNode<String> root;
BTNode<String> 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<String>(ROOT_QUESTION, null,
null);
// Create and attach the left subtree.
child = new BTNode<String>(LEFT_QUESTION, null,
null);
child.setLeft(new BTNode<String>(ANIMAL1, null, null));
child.setRight(new BTNode<String>(ANIMAL2, null,
null));
root.setLeft(child);
// Create and attach the right subtree.
child = new BTNode<String>(RIGHT_QUESTION, null,

null);
child.setLeft(new BTNode<String>(ANIMAL3, null, null));
child.setRight(new BTNode<String>(ANIMAL4, null,
null));
root.setRight(child);
return root;
}
/**
* Elicits information from the user to improve a binary
taxonomy tree.
* @param <CODE>current</CODE>
* a reference to a leaf node of a binary taxonomy tree
* <CODE>current</CODE> is a reference to a leaf in a
binary
* taxonomy tree

* Information has been elicited from the user, and the tree
has
* been improved.
* Indicates that there is insufficient memory to add new
* information to the tree.
**/
public static void learn(BTNode<String> 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<String>(correctAnimal, null,
null));

current.setRight(new BTNode<String>(guessAnimal, null,
null));
}
else
{
current.setLeft(new BTNode<String>(guessAnimal, null,
null));
current.setRight(new BTNode<String>(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 <CODE>IntTreeBag</CODE> is a collection of int
numbers.
*
* <dl><dt>Limitations: <dd>
* Beyond <CODE>Integer.MAX_VALUE</CODE> elements,
<CODE>countOccurrences</CODE>,

* and <CODE>size</CODE> are wrong.
*
* <dt>Outline of Java Source Code for this class:<dd>
* <A
HREF="../../../../edu/colorado/collections/IntTreeBag.java">
*
http://www.cs.colorado.edu/~main/edu/colorado/collections/Int
TreeBag.java
* </A>
*
* <dt>Note:<dd>
* 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 <CODE>element</CODE>
* the new element that is being inserted
* A new copy of the element has been added to this bag.

* Indicates insufficient memory a new IntBTNode.
**/
public void add(int element)
{
// Implemented by student.
}
/**
* Add the contents of another bag to this bag.
* @param <CODE>addend</CODE>
* a bag whose contents will be added to this bag
* The parameter, <CODE>addend</CODE>, is not null.
* The elements from <CODE>addend</CODE> have been
added to this bag.
* @exception IllegalArgumentException

* Indicates that <CODE>addend</CODE> is null.
* 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

<CODE>IntTreeBag</CODE> before it can be used.
* 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 <CODE>target</CODE>
* the element that needs to be counted
* @return

* the number of times that <CODE>target</CODE> occurs
in this bag
**/
public int countOccurrences(int target)
{
code:
return 0;
}
/**
* Remove one copy of a specified element from this bag.
* @param <CODE>target</CODE>
* the element to remove from the bag
* If <CODE>target</CODE> was found in the bag, then one
copy of
* <CODE>target</CODE> has been removed and the method
returns true.

* Otherwise the bag remains unchanged and the method
returns false.
**/
private boolean remove(int target)
{
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 <CODE>b1</CODE>
* the first of two bags
* @param <CODE>b2</CODE>
* the second of two bags
* Neither b1 nor b2 is null.
* @return
* the union of b1 and b2
* @exception IllegalArgumentException
* Indicates that one of the arguments is null.
* Indicates insufficient memory for the new bag.

**/
public static IntTreeBag union(IntTreeBag b1, IntTreeBag b2)
{
code:
return null;
}
}
1
AUDIT PROGRAM DESIGN
AUDIT PROGRAM DESIGN
Audit Program Design Part III
Jocelyn Olivares
University of Phoenix
ACC546

Professor Theresa Robinson
December 1, 2012
Introduction
In order to conduct a substantial audit of Apollo Shoes the
auditor must obtain a sufficient understanding of the entity and
the entity’s environment, including the internal control. The
understanding of the entity and its environment helps the
auditor in a variety of ways throughout the audit, including
establishing materiality, considering appropriateness, and
designing audit procedures that can facilitate the growth of
Apollo Shoes. Before the auditor can begin the process of
conducting the audit of the inventory and warehousing cash
cycles, the auditor must prepare the audit plan and program for
Apollo Shoes.
Developing the audit strategy and plan aids the auditor in
determining the necessary resources to perform the engagement.
The auditor must develop a plan in mind that will reduce audit
risk to an acceptable level for the inventory and warehousing
cash cycle. The audit plan should include a description of
nature, timing, and extent of the planned risk assessment
procedures. The audit plan and program significantly affects the
types and extent of further audit procedures to be used by the
auditor in determining whether the financial statements are
fairly stated in accordance with the US GAAP. The auditor
should consider audit risk in relation to the individual account
balances, classes of transactions, and disclosures and relevant
assertions of the overall level of the financial statements.
These further audit procedures include test of controls,
substantive tests of transactions and analytical procedures with
the evidence collected from these procedures forming part of
the auditor’s sufficient and appropriate evidence to support his

audit opinion and report in accordance with the US generally
accepted auditing standards. With designing the test of controls
and substantive tests of transactions for the each of the two
cycles, Apollo Shoes, Inc.’s internal control over these accounts
must first be understood by the auditor; the auditor assesses the
planned control risk for that account. Below illustrates the
general procedures and methodology in designing tests of
controls and substantive tests of transactions for any account
that is audited:
1. Understand the internal control over that cycle or account
2. Assess the planned control risk for that cycle
3. Determined the extent of testing controls which is based on
the planned reliance on the controls over financial reporting for
that account of the audit client
4. Design tests of controls and substantive tests of transactions
for the account to meet transactions-related audit objectives.
The design of tests of controls and substantive tests of
transactions involve determining the specific audit procedures
to be performed, the sample size, items to be selected and
included in the sample, and timing of the tests.
Inventory and warehousing Cycle
Test of controls
The auditor in charge has to determine the control procedures
over the inventory and warehousing cycle of Apollo Shoes, Inc.
and their deficiencies in designing the test of controls.
Substantive Tests of Transactions

For each transaction-related audit objectives – occurrence,
completeness, accuracy, posting and summarization,
classification and timing – a substantive test or more must be
associated. These tests are used to examine the actual details
that make-up the various account balances and disclosures.
Analytical Procedures
According to AU 329, requires that analytical procedures be
performed in planning of the audit, as well as an overall review
nearing the completion of the audit. These procedures serve to
provide the auditor additional assurance that the account is
presented fairly in accordance with generally accepted
accounting principles. The table below shows the test of
controls, substantive tests of transactions, and analytical
procedures for a couple of the transaction-related audit
objectives of Apollo’s inventory and warehousing cycle.
Transaction-Related Audit Objectives | Key Internal Controls |
Tests of Controls | Substantive Tests of Transactions |
Recorded inventory acquisition transactions are accurate
(accuracy) | Calculations and amounts are internally verified |
Examine indication of internal verification | Compare recorded
transitions in the inventory acquisitions journal with the
vendor’s invoice, receiving report, and other supporting
documents both internally and externally sourced. |
| Batch totals are compared with summary reports for inventory
purchases | Examine file of batch totals for initials of data
control clerk, then compare the batch totals with the summary
reports | Recomputed the accuracy of the vendor’s invoice. |
Cash Cycle
Test of controls

For each of the identified internal control and control
deficiencies over financial reporting of cash, one or more tests
of controls must be designed (Arens, Elder & Beasley, 2008, p.
453). The tests of controls are used either to test the
effectiveness of the design or the operation of the control. The
approach should include:
1. Inquiries of appropriate personnel
2. Inspection of documents and reports
3. Observation of the application of controls
4. Re-performance of the control by the auditor
Substantive tests of transactions
The substantive tests of transactions for cash are related to the
transaction-related audit objectives identified in the test of
controls. These tests are designed to aid the auditor in
determining whether there are any monetary misstatements for
each objective in a cash transaction.
Analytical Procedure
Analytical procedures on the other hand involve the comparison
of the financial statements information presented to determine
any potential misstatement with that of the previous period. The
table below presents the test of controls and substantive tests of
transactions for cash receipts of Apollo Shoes Inc. as adopted
from the test of controls and substantive tests of transactions
designed by Arens, Elder and Beasley for Hillsburg Hardware
Co. (2008, p. 463).
Transaction-Related Audit Objectives | Key Existing Controls |

Test of Controls | Deficiencies | Substantive Test of
Transactions |
Recorded cash receipts are for funds actually received by
Apollo (occurrence) | Accountant independently reconciles bank
account. | Observe whether the accountant in charge really does
reconcile the bank accounts | | Review Apollo’s cash receipts
and master file for unusual transactions and amounts.Prepare a
proof of cash receipts |
Cash received is recorded in the cash receipts journal
(completeness) | Prelisting of cash receipts is prepared |
Observed prelisting of cash receipts | | Obtain prelisting of cash
receipts and trace amounts to the cash receipts journal, testing
from names, amounts and dates. |
In closing, the above audit objectives and test of transactions,
the above procedures must be revised based on the actual audit
plan and program designed for Apollo Shoes, Inc.
References
Arens, A., Elder, R. & Beasley, M. (2008). Auditing and
Assurance Services: An Integrated Approach (12th ed). New
York: Pearson Education.
Louwers,T.J., & Reynolds, J.K. (2002 ). Apollo shoes casebook.
New York, New York:
McGraw-Hill.
2
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.
The constructor would require linear time.
B.
The getFront method would require linear time.
C.
The insert method would require linear time.

D.
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
C. 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
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.
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?

For this project, write a program that stores integers in a binary.docx

For this project, write a program that stores integers in a binary.docx

More Related Content

Similar to For this project, write a program that stores integers in a binary.docx

More from budbarber38650

Recently uploaded

For this project, write a program that stores integers in a binary.docx