CS 2114 Combo
You should express the complexity of an algorithm in terms of it
problem size
At the time a method is called during program execution, the activation record is pushed onto the
program stack
When you remove an item from a stack, you remove it from
the top
The selection sort requires _____ comparisons for an array of n items
O(n^2)
What is the scope error in the mystery method? public static void main(String[] args) { int target = 4; target = mystery(target + 1); System.out.println(sum); } public static int mystery(int target) { int sum = 0; for (int i = 0; i < target; target++) { int target = i + 1; sum = sum + target; } return sum; }
there are two local variables named target that overlap
If iteration has ended, the next method
throws a NoSuchElementException
An algorithm has
time requirements and space requirements
the operator == tests to see if
two variables reference the same place in the computer's memory
What is the worst-case time complexity for searching a linked-based bag ADT for a particular entry?
O(n)
After the following statements execute, what item is at the front of the queue? QueueInterface zooDelivery = new LinkedQueue(); zooDelivery .enqueue("lion"); zooDelivery .enqueue("tiger"); zooDelivery .enqueue("cheetah"); String next = zooDelivery .dequeue(); next = zooDelivery .dequeue(); zooDelivery .enqueue("jaguar");
"cheetah"
For large values of n which statement is true?
(n^2 + n ) / 2 behaves like n^2
In the Ch 6 an array-based implementation of a Stack ADT, what value for the topindex of the stack indicates that it is empty?
-1
How many recursive calls will be made if the following method is called with 6 from main? void greeting(int n) { if (n > 0) { System.out.println("Hello!"); greeting(n-1); } }
6
What is the output of the following program when the method is called with 4? void unknown(int n) { if (n > 0) { System.out.print("?"); unknown(n-1); } }
????
What is the output of the following program when the method is called with 4? void unknown(int n) { if (n > 0) unknown(n-1); System.out.print("?"); }
?????
What is the output of the following program when the method is called with 4? void unknown(int n) { System.out.print("?"); if (n > 0) unknown(n-1); }
?????
Given an array of doubles named values, what does the following code do: double total = 0; for(double element : values) { total = total + element; } double average = 0; if (values.length > 0) { average = total/values.length; }
Calculates the sum and average of the values
Java sorting implementations sort objects that implement the _____ interface.
Comparable
What question should you keep in mind when debugging a recursive method?
Does each base case produce a result that is correct for that case? Are there enough base cases? Is at least one of the cases a base case that has no recursive call?
Given an array of ints named values, what does the following code do: for (int i = 0; i < values.length; i++) { values[i] = i * i; }
Fills the array with squares (0, 1, 4, 9, 16, ...)
Given an array of ints named values, what does this code do? double largest = values[0]; for (int i = 1; i < values.length; i++) { if (values[i] > largest) { largest = values[i]; } }
Find the max value
What is usually an advantage of using a chain to implement the ADT bag?
It avoids moving data when adding or removing bag entries.
The use of a generic data type is preferred over using Object as a general class in a collection because
It ensures that all the members of the collection are objects related by inheritance.
If an algorithm requires 7 basic operations for an algorithm with a problem size of n, the algorithmic complexity is
O(1)
In a circular array-based implementation of a queue, what is the performance when the dequeue operation?
O(1)
In a linked chain implementation of a queue, the performance of the enqueue operation is
O(1)
In a linked-based implementation of the ADT list with a tail reference, what is the performance of adding an entry at the end of the list?
O(1)
In the Ch 6 linked-chain implementation of a Stack ADT, the performance of popping an entry from the stack is
O(1)
What is the time complexity for adding an entry to a fixed-size array-based bag ADT?
O(1)
What is the time complexity for adding an entry to a linked-based bag ADT?
O(1)
The efficiency for recursively traversing a chain of linked nodes is
O(n)
Bridget
REEEE
What item is at the front of the list after these statements are executed? DequeInterface waitingLine = new LinkedDeque(); waitingLine.addToFront("Jack"); waitingLine.addToFront("Rudy"); waitingLine.addToBack("Larry"); waitingLine.addToBack("Sam"); String name = waitingLine.getBack();
Rudy
What item is at the front of the list after these statements are executed? DequeInterface waitingLine = new LinkedDeque(); waitingLine.addToFront("Jack"); waitingLine.addToFront("Rudy"); waitingLine.addToBack("Larry"); waitingLine.addToBack("Sam"); String name = waitingLine.getFront();
Rudy
What item is at the front of the list after these statements are executed? DequeInterface waitingLine = new LinkedDeque(); waitingLine.addToFront("Jack"); waitingLine.addToBack("Rudy"); waitingLine.addToBack("Larry"); waitingLine.addToFront("Sam"); String name = waitingLine.getFront(); name = waitingLine.getBack();
Sam
What will be ouput as a result of a call to the calculate method? private int sum = 0; private int product = 0; public static final int AMOUNT = 5; public void output(){ System.out.println("The sum of the numbers from 1 to " + AMOUNT + " is " + sum); System.out.println("The product of the numbers from 1 to " + AMOUNT + " is " + product); } public void calculate(){ int sum = 0; int product = 1; for (int i = 1; i <= AMOUNT; i++){ sum = sum + i; product = product * i; } output(); }
The sum of the numbers from 1 to 5 is 0 The product of the numbers from 1 to 5 is 0
When adding an item to a bag, which of the following statements are true?
You cannot specify the position of the item in the bag.
A class uses composition when it
declares an instance of another class as a data field
Given the following infix expression, which one of the following is the corresponding postfix expression? (a + b) * (c - d) / (e + f)
a b + c d - * e f + /
what does a reference type represent?
a memory address instead of the actual item stored at that address
What does the"new" operator do in the following code from the LinkedBag add method: Node newNode = new Node(newEntry);
a new node is created the JRE allocates memory for a node object a new object is instantiated
After a call to remove, the nextPosition data field should be
decremented
In a chain of linked nodes you can
add nodes from the beginning of a chain add nodes from the end of a chain add nodes that are between other nodes
Which behavior(s) change the contents of a bag?
add()
Which of the following is usually an advantage of using an array to implement the ADT bag?
adding an entry to a bag is fast
In the Carrano ListInterface, the method with the signature: public void add(int newPosition, T newEntry); does which of the following
adds a new entry to the specified position in the list increases the list size by 1 moves entries originally at or above the specified position one position higher
implementation
all the data fields and details of the methods definitions
A key benefit of inheritance is
an object can have several types, it is type compatible with any of its superclasses
a variable declared as an interface type can reference
any object of a class that implements that interface
Where does a queue add new items?
at the back
You can add a new entry in a list
at the beginning at the end in between items
Where will you find the item added earliest to a queue?
at the front
An expression that has correctly paired delimiters is called a(n)
balanced expression
Recursive methods need a(n)
base case
A superclass is also called a(n)
base class
A subclass is also called a(n)
derived class
encapsulation
design principle that encloses data and methods within a class, thereby hiding the class' implementation details
this();
calls the constructor of the current class that takes no arguments
super();
calls the constructor of the parent class that takes no arguments
Which method removes all entries of a bag?
clear()
In the LList implementation of a list, given a node called currentNode, which statement moves the node's reference to the next node?
currentNode = currentNode.getNextNode();
When adding an entry to an array-based implementation of the ADT list at a specified location before the end of the list
entries must be shifted to vacate a position for the new item
To efficiently remove a node at the end of a linked chain implementation of a queue requires a
extra reference in the node pointing to the previous node
What type of behavior defines a queue?
first-in first-out
abstraction
focus on what and not how
Which method returns a count of the current number of items in a bag?
getCurrentSize()
A fixed size array
has a limited capacity can waste memory prevents expansion when the bag becomes full
composition
has-a-relationship
Which method does the interface Iterator specify?
hasNext next remove
A reference to the first node in a linked list is called the _____ reference.
head
Shane
hep
How many recursive calls will be made if the following method is called with 6 from main? void greeting(int n) { if (n > 0) { System.out.println("Hello!"); greeting(n+1); } }
infinite
How many recursive calls will be made if the following method is called with 6 from main? void greeting(int n) { System.out.println("Hello!"); greeting(n-1); }
infinite
Placing the Node class inside the LinkedBag class makes it a(n)
inner class
inheritance
is-a-relationship
Which of the following are good reasons to write tests that use your bag ADT before the implementation is done?
it helps confirm the design it helps check the suitability of the specification it helps check your understanding of the specification
In an array-based implementation of the ADT list, the makeRoom method does the most work when
newPosition is 1
In the Carrano LList implementation of a list, when a list is empty the firstNode is _____ and the numberOfEntries is _____.
null, 0
In a circular array-based implementation of a queue, the initial size of the array should be
one more than the queue's inital capacity
In the Carrano ListInterface, the method with the signature: public T remove(int givenPosition); does which of the following:
removes the entry at a given position from the list
The fixed array implementation of the method remove that has no parameter in the bag
removes the last entry in the array
Which behavior is not represented in a bag?
reorder the bag
The most efficient approach to dealing with a gap left in an array after removing an entry from a bag is to
replace the entry being removed with the last entry in the array and replace the last entry with null
In your reading, the pop and peek methods throw a(n) ________ exception when the stack is empty.
runtime
Selecting the smallest element of an array and swapping it with the smallest entry is an operation in which sorting method?
selection sort
What does a primitive type represent?
simple indecomposable values
When too many recursive calls are made creating more activation records than the allocated program memory can handle, what kind of error occurs?
stack overflow
An incomplete definition of a method is called a _____.
stub
What is the scope error in the main method? public static void main(String[] args) { int target = 4; sum = mystery(target + 1); System.out.println(sum); } public static int mystery(int target) { int sum = 0; for (int i = 0; i < target; i++) { int target = i + 1; sum = sum + target; } return sum; }
sum is not declared
Because SortedList is derived from LList, you write _____.add(newPosition, newEntry) to invoke the add operation of the ADT list
super
The node that is easiest to access in a linked-chain is
the head node
In the Ch 6 array-based implementation of a Stack ADT, the entry peek returns may be found at
the last occupied location in the array
when one method has the same name but a different set of parameters than a second method
the method are overloaded
Problem size is defined as
the number of items an algorithms processes
In the Ch 6 linked-chain implementation of a Stack ADT, when a node is popped from the stack
the original first node will no longer be referenced the original first node will be deallocated the new first node will reference what was the second node in the chain
In the linked chain implementation of a queue, the chain's first node contains
the queue's front entry
What are the consequences of returning a reference to the bag array in the toArray method?
the return variable is an alias for the private instance array variable the client will have direct access to the private instance array variable the client could change the contents of the private instance array variable without using the public access methods
If the SortedList class inherited the remove by position method from the LList class
we would not have to implement it again
client interface
what client code needs to know to use a class
Why would the add method return false?
when the addition of a new item was not successful