Test #2 Data Structures & Algorithms
How many external references are necessary when implementing a queue using a circularly-linked list? 1 none 4 2
1
Queues are used by compilers to implement recursive methods. TF?
False
Which of the following is NOT an operation that can be performed on a stack: peek insert push pop
Insert
A merge sort is used to sort an array of 1000 values in ascending order. Which of the following statements is true? The sort is fastest if the original values are in completely random order. The sort is the same, no matter what the order of the original elements. The sort is fastest is the original values are sorted from smallest to largest. The sort is fastest if the original values are sorted from largest to smallest.
The sort is the same, no matter what the order of the original elements.
Queues are rarely used in simulation programs. TF?
false
The efficiency of the selection sort depends on the initial arrangement of the data.
false
When implementing a queue using an array-based approach, it is not necessary to determine if the queue if full before adding a new item to the queue. TF?
false
Which of the following operations would you focus on in order to assess the efficiency of a sorting algorithm? multiplication addition loops comparisons
Comparisons
A referenced-based queue implementation uses a statically allocated linked-list. TF?
False
A stack is a first in first out data structure. TF?
False
According to the following statements: -- Algorithm A requires time proportional to n2 -- Algorithm B requires time proportional to nlog2n Algorithm A's time requirement (as a function of the problem size n) increases at a slower rate than algorithm B's time requirement. TF?
False
In a stack operation, new items can only be added to the bottom of the stack. TF?
False
Stacks can be implemented only using arrays. TF?
False
The binary search algorithm is a quadratic algorithm. TF?
False
The values of the growth-rate function O(log2n) grow faster than the values of the growth-rate function O(n). TF?
False
When implementing a queue using a reference-based approach, the operation dequeueAll is not needed. TF?
False
When implementing a queue, a naive array approach is more efficient in terms of memory when compared to a circular array approach. TF?
False
Suppose you are using a queueing system to simulate the movement of pallets in a warehouse. What would represent the server in the simulation? Forklift pallets Warehouse
Forklift
Which of the following would not be a good use of a stack: Keyboard buffer checking for balanced parenthesis Displaying text in reverse
Keyboard Buffer
Suppose that a selection sort of n items requires n2/2 + 5 * n/2 - 3 basic operations -- the selection sort is: O(n) O(1) O(n2) O(n2/2)
O(n2)
Given the fact that a sort of n items requires n2/2 + 5 * n/2 - 3 major operations, the sort is ______. O(n^2/2) O( n^2/2 + 5 * n/2 - 3) O(n^2) O(n)
O(n^2)
The quicksort is ______ in the worst case. O(nlog2n) O(log2n) O(n2) O(n3)
O(n^2)
Which of the following would result in an error? Popping an empty stack Pushing an item onto a empty stack peeking a full stack
Popping an empty stack
Which of the following is true of an array-based stack implementation: Uses memory more efficiently Requires an IsFull Method to check for a empty stack Size of the stack can grow dynamically
Requires an IsFull Method
Which of the following is true of implementing a stack using a linked list: The head reference for the stack points to the bottom of the stack The next reference for the bottom of the stack is null The stack cannot grow dynamically
The next reference for the bottom of the stack is null
A comparison of algorithms should focus on significant differences, not reductions in computing costs based on clever coding tricks. TF?
True
If 5 items are added to the queue, the first item to be removed from the queue is the first item that was added to the queue. TF?
True
Low-order terms can be ignored in an algorithm's growth-rate function. TF?
True
Queues are FIFO (first in first out)? TF?
True
Stacks are used by compilers to implement recursion
True
Stacks can be used to solve depth first searches on graphs. TF?
True
The deletion of an item from one-element reference based queue is a special case. TF?
True
When working with a stack, peek removes the value from the top of the stack. TF?
True
Which of the following is NOT a means of implementing a queue: linearly linked list circularly linked list linear array all of these can be used to implement a queue circularly linked lis
all of these can be used to implement a queue
Operations on a queue can be carried out at ______. its front only any position in the queue its back only both front and back
both front and back
Which of the following should algorithm analysis be independent of: data it should be independent of all of these computers specific implementation
it should be independent of all of these
When assessing the efficiency of a factorial program, which of the following operations would you focus on: muliplication addition loops comparisons
multiplication
In the worst case, the insertion sort's comparison occurs how many times? n n - 1 (n - 1)/2 n*(n - 1)/2
n*(n - 1)/2
A bubble sort requires at most how many passes to sort an array of n items? n/2 n-2 n n-1
n-1
If a stack is used by an algorithm to check for balanced braces, which of the following is true once the end of the string is reached? the stack has one { left the stack has one pair of {} left the stack is empty the stack has one } left
the stack is empty
The two types of simulations are event-driven and _______. queue driven statistically driven probability driven time driven
time driven
A queue can be used as a keyboard buffer. TF?
true
A reference-based implementation of a queue that uses a linear singly linked list would need at least ______ external references.
two
Consider the following Java array definition: int[] array = {22,18,23,16,19,26,15,13}; Suppose this list was to be sorted by the selection sort algorithm as discussed in class. What would be the arrangement of the list after the fourth pass through the array? 13 15 16 18 26 22 19 23 13 15 16 23 19 26 23 22 13 15 16 18 19 22 26 23 13 15 16 18 19 22 23 26 13 15 16 18 19 26 23 22
13 15 16 18 19 26 23 22
Consider the following Java array definition: int[] array = {22,18,23,16,19,26,15,13}; Suppose this list was to be sorted with the recursive mergeSort method demonstrated in class. How many times would the mergeSort method be invoked to successfully sort the given array? 16 15 8 1 2
15
Consider the following Java array definition: int[] array = {22,13,23,15,19,16,26,18}; Suppose this array is to be sorted with the bubble sort algorithm as discussed in class. How many comparisons would be made in order to arrange the data into ascending order? 25 7 28 64 22
25
Which of the following growth functions would represent the most inefficient algorithm for solving a problem: 2^n n^2 n log 2 n
2^n
Suppose that the following list: 71 44 47 68 18 49 73 11 24 57 33 26 was input to the (external) replacement sorting algorithm as discussed in class. How many initial "runs" would be created by the algorithm. You may assume that the sort work area allows for only four data items at any one time: 7 6 5 3 4
5
Suppose that the following list: 479 681 532 94 353 760 was input to the radix sort algorithm. What would be the arrangement of the list after the second pass of the algorithm? 94 353 479 532 681 760 479 681 532 94 353 760 532 353 760 479 681 94 760 681 532 353 94 479
532 353 760 479 681 94
Which of the following arrays represents a heap? 87 26 41 54 25 24 28 20 19 17 87 41 54 28 26 19 25 17 20 24 24 41 54 28 26 19 25 17 20 87 17 19 20 24 25 26 28 41 54 87
87 41 54 28 26 19 25 17 20 24
When implementing a stack as a linked-list, you must make sure the stack isn't full before you can push a new item onto it. TF?
False
A reference-based stack makes more efficient use of memory. TF?
True
The last item to be added to a stack is the first item to be removed from the stack. TF?
True
The pop operation throws a StackException when it tries to: delete an item from an empty stack add an item to a array-based implementation stack when it is already full add an empty item to a empty stack delete an item from an array-based implementation of a stack when it is already full
delete an item from an empty stack
Which of the following operations inserts an element at the end of the queue: peek dequeue push enqueue
enqueue
Which of the following code fragments is used to delete the item at the front of a queue represented by a circular array? front = (front+1) % MAX_QUEUE; --count; ----------------- front = front - back; --count; ---------------- front = MAX_QUEUE - front; --count; ---------------- front = (back+1) % MAX_QUEUE; --count;
front = (front+1) % MAX_QUEUE; --count;
Which of the following is the code to insert a new node, referenced by newNode, into an empty queue represented by a circular linked list? newNode.setNext(lastNode); newNode = lastNode; ----------------------- newNode.setNext(newNode); lastNode = newNode; ------------------------ newNode.setNext(lastNode); ------------------------- lastNode.setNext(lastNode); lastNode = newNode;
newNode.setNext(newNode); lastNode = newNode;
