Question 1

When your class implements a comparator object, you must implement the compare method. What must be true about the return value from this method when comparing two objects, a and b with a call to a.compare(b)?

Accepted Answer

A)  It must return 1 if a comes before b, 0 if they are the same, and -1 if a comes after b. 
B)  It must return -1 if a comes before b, 0 if they are the same, and 1 if a comes after b. 
C)  It must return a positive value if a comes before b, 0 if they are the same, and a negative value if a comes after b. 
D)  It must return a negative value if a comes before b, 0 if they are the same, and a positive value if a comes after b.

Question 2

When does quicksort's worst-case run-time behavior occur?
I when the data is randomly initialized in the array
II when the data is in ascending order
III when the data is in descending order

Accepted Answer

A)  I 
B)  II 
C)  III 
D)  II and III

Question 3

If an element is present in an array of length n, how many element visits, in the worst case, are necessary to find it using a linear search?

Accepted Answer

A)  n / 2 
B)  n 
C)  2n 
D)  n2

Question 4

Given the following code snippet for searching an array:
Int[] arr = {3, 8, 12, 14, 17};
Int newVal = 15;
Int pos = Arrays.binarySearch(arr, newVal);
What value will pos have when this code is executed?

Accepted Answer

A)  5 
B)  -5 
C)  6 
D)  -6

Question 5

Given an ordered array with 15 elements, how many elements must be visited in the worst case of binary search?

Accepted Answer

A)  8 
B)  4 
C)  3 
D)  2

Question 6

Merge sort has a O(n log2(n)) complexity. If a computer can sort 1,024 elements in an amount of time x, approximately how much longer will it take the computer to sort 1,024 times that many, or 1,048,576 elements?

Accepted Answer

A)  1,024 times longer 
B)  2,048 times longer 
C)  8,192 times longer 
D)  1,048,576 times longer

Question 7

Which of the sorts in the textbook are based on the strategy of divide and conquer?
I quicksort
II mergesort
III insertion sort

Accepted Answer

A)  I 
B)  II 
C)  III 
D)  I and II

Question 8

If the array is already sorted, what is the performance of insertion sort?

Accepted Answer

A)  O(n) 
B)  O(n2) 
C)  O(log n) 
D)  O(n log n)

Question 9

An algorithm that tests whether the first array element is equal to any of the other array elements would be an ____ algorithm.

Accepted Answer

A)  O(1) 
B)  O(n) 
C)  O(log (n)) 
D)  O(n log (n))

Question 10

In Big-Oh notation, selection sort is a(n) ____ algorithm.

Accepted Answer

A)  O(n2) 
B)  O(1) 
C)  log n 
D)  O(log n2)

Question 11

The method checkArray examines an array arr:
Public static boolean checkArray(int[] arr)
{
If (arr[0] >= arr[arr.length -1])
{
Return true;
}
Return false;
}
What can you conclude about the running time of this section of code?

Accepted Answer

A)  Its running time will be O(n). 
B)  Its running time will be O(n2). 
C)  Its running time will be O(log (n)). 
D)  Its running time will be O(1).

Question 12

In the worst case, a linear search locates a value in an array of length n in ____ steps.

Accepted Answer

A)  O(n2) 
B)  O(log n) 
C)  O(n) 
D)  O(log n2)

Question 13

If a call to the Arrays static method binarySearch returns a value of -10, what can be concluded?
I the element is not in the array
II the element is at index 10
III the element can be inserted at index 9

Accepted Answer

A)  I 
B)  II 
C)  III 
D)  I and III

Question 14

Assume we are using quicksort to sort an array in ascending order. What can we conclude about the elements to the left of the currently placed pivot element?

Accepted Answer

A)  They are all sorted. 
B)  They are all less than or equal to the pivot element. 
C)  They are all greater than or equal to the pivot element. 
D)  None can equal the pivot element.

Question 15

In the textbook, we found that the number of element visits for merge sort totaled
N + 5nlog2n. Let's consider sorting 1024 elements. How many visits are needed?

Accepted Answer

A)  1.024 
B)  6,144 
C)  51,200 
D)  52,224

Question 16

Consider the following code snippet:
Public static void sort(int[] a) {
For (int i = 1; i  0 && a[j - 1] > next)
{
a[j] = a[j - 1];
j--;
}
a[j] = next;
}
}
What sort algorithm is used in this code?

Accepted Answer

A)  insertion sort 
B)  selection sort 
C)  merge sort 
D)  quicksort

Question 17

Suppose you wish to implement the Comparable interface to allow your Vehicle class to compare Auto objects only. Which of the following is the correct way to do this?

Accepted Answer

A) public class Auto implements Comparable B) public class Vehicle implements Comparable C) public class Vehicle implements Comparable D) public class Vehicle implements Comparable(Auto)

Question 18

Suppose an array has n elements. We visit element #1 one time, element #2 two times, element #3 three times, and so forth. How many total visits will there be?

Accepted Answer

A)  2n 
B)  n(n+1)/2 
C)  n2 
D)  n3

Question 19

An algorithm that cuts the work in half in each step is an ____ algorithm.

Accepted Answer

A)  O(n) 
B)  O(n2) 
C)  O(log (n)) 
D)  O(n log (n))

Question 20

Consider the sort method for selection sort shown below:
Public static void sort (int[] a) {
For (int i = 0; i < a.length - 1; i++)
{
Int minPos = minimumPosition(i);
Swap(minPos, i);
}
}
Suppose we modify the loop control to read int i = 1; i < a.length - 1; i++. What would be the result?

Accepted Answer

A)  An exception would occur 
B)  The sort would not consider the last array element. 
C)  The sort would not consider the first array element. 
D)  The sort would still work correctly.

Exam 14: Sorting and Searching

When your class implements a comparator object, you must implement the compare method. What must be true about the return value from this method when comparing two objects, a and b with a call to a.compare(b) ?

When does quicksort's worst-case run-time behavior occur? I when the data is randomly initialized in the array II when the data is in ascending order III when the data is in descending order

If an element is present in an array of length n, how many element visits, in the worst case, are necessary to find it using a linear search?

Given the following code snippet for searching an array: Int[] arr = {3, 8, 12, 14, 17}; Int newVal = 15; Int pos = Arrays.binarySearch(arr, newVal) ; What value will pos have when this code is executed?

Given an ordered array with 15 elements, how many elements must be visited in the worst case of binary search?

Merge sort has a O(n log₂(n) ) complexity. If a computer can sort 1,024 elements in an amount of time x, approximately how much longer will it take the computer to sort 1,024 times that many, or 1,048,576 elements?

Which of the sorts in the textbook are based on the strategy of divide and conquer? I quicksort II mergesort III insertion sort

If the array is already sorted, what is the performance of insertion sort?

An algorithm that tests whether the first array element is equal to any of the other array elements would be an ____ algorithm.

In Big-Oh notation, selection sort is a(n) ____ algorithm.

The method checkArray examines an array arr: Public static boolean checkArray(int[] arr) { If (arr[0] >= arr[arr.length -1]) { Return true; } Return false; } What can you conclude about the running time of this section of code?

In the worst case, a linear search locates a value in an array of length n in ____ steps.

If a call to the Arrays static method binarySearch returns a value of -10, what can be concluded? I the element is not in the array II the element is at index 10 III the element can be inserted at index 9

Assume we are using quicksort to sort an array in ascending order. What can we conclude about the elements to the left of the currently placed pivot element?

In the textbook, we found that the number of element visits for merge sort totaled N + 5nlog₂n. Let's consider sorting 1024 elements. How many visits are needed?

Consider the following code snippet: Public static void sort(int[] a) { For (int i = 1; i < a.length; i++) { int next = a[i]; int j = i; while (j > 0 && a[j - 1] > next) { a[j] = a[j - 1]; j--; } a[j] = next; } } What sort algorithm is used in this code?

Suppose you wish to implement the Comparable interface to allow your Vehicle class to compare Auto objects only. Which of the following is the correct way to do this?

Suppose an array has n elements. We visit element #1 one time, element #2 two times, element #3 three times, and so forth. How many total visits will there be?

An algorithm that cuts the work in half in each step is an ____ algorithm.

Consider the sort method for selection sort shown below: Public static void sort (int[] a) { For (int i = 0; i < a.length - 1; i++) { Int minPos = minimumPosition(i) ; Swap(minPos, i) ; } } Suppose we modify the loop control to read int i = 1; i < a.length - 1; i++. What would be the result?

Exam 14: Sorting and Searching

When your class implements a comparator object, you must implement the compare method. What must be true about the return value from this method when comparing two objects, a and b with a call to a.compare(b) ?

When does quicksort's worst-case run-time behavior occur? I when the data is randomly initialized in the array II when the data is in ascending order III when the data is in descending order

If an element is present in an array of length n, how many element visits, in the worst case, are necessary to find it using a linear search?

Given the following code snippet for searching an array: Int[] arr = {3, 8, 12, 14, 17}; Int newVal = 15; Int pos = Arrays.binarySearch(arr, newVal) ; What value will pos have when this code is executed?

Given an ordered array with 15 elements, how many elements must be visited in the worst case of binary search?

Merge sort has a O(n log2(n) ) complexity. If a computer can sort 1,024 elements in an amount of time x, approximately how much longer will it take the computer to sort 1,024 times that many, or 1,048,576 elements?

Which of the sorts in the textbook are based on the strategy of divide and conquer? I quicksort II mergesort III insertion sort

If the array is already sorted, what is the performance of insertion sort?

An algorithm that tests whether the first array element is equal to any of the other array elements would be an ____ algorithm.

In Big-Oh notation, selection sort is a(n) ____ algorithm.

The method checkArray examines an array arr: Public static boolean checkArray(int[] arr) { If (arr[0] >= arr[arr.length -1]) { Return true; } Return false; } What can you conclude about the running time of this section of code?

In the worst case, a linear search locates a value in an array of length n in ____ steps.

If a call to the Arrays static method binarySearch returns a value of -10, what can be concluded? I the element is not in the array II the element is at index 10 III the element can be inserted at index 9

Assume we are using quicksort to sort an array in ascending order. What can we conclude about the elements to the left of the currently placed pivot element?

In the textbook, we found that the number of element visits for merge sort totaled N + 5nlog2n. Let's consider sorting 1024 elements. How many visits are needed?

Consider the following code snippet: Public static void sort(int[] a) { For (int i = 1; i < a.length; i++) { int next = a[i]; int j = i; while (j > 0 && a[j - 1] > next) { a[j] = a[j - 1]; j--; } a[j] = next; } } What sort algorithm is used in this code?

Suppose you wish to implement the Comparable interface to allow your Vehicle class to compare Auto objects only. Which of the following is the correct way to do this?

Suppose an array has n elements. We visit element #1 one time, element #2 two times, element #3 three times, and so forth. How many total visits will there be?

An algorithm that cuts the work in half in each step is an ____ algorithm.

Consider the sort method for selection sort shown below: Public static void sort (int[] a) { For (int i = 0; i < a.length - 1; i++) { Int minPos = minimumPosition(i) ; Swap(minPos, i) ; } } Suppose we modify the loop control to read int i = 1; i < a.length - 1; i++. What would be the result?

Merge sort has a O(n log₂(n) ) complexity. If a computer can sort 1,024 elements in an amount of time x, approximately how much longer will it take the computer to sort 1,024 times that many, or 1,048,576 elements?

In the textbook, we found that the number of element visits for merge sort totaled N + 5nlog₂n. Let's consider sorting 1024 elements. How many visits are needed?