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?