An algorithm for searching a large sorted array for a specific value x compares every third item in the array to x until it finds one that is greater than or equal to x. When a larger value is found, the algorithm compares x to the previous two items. If the array is sorted in increasing order, which of the following de- scribes all cases when this algorithm uses fewer comparisons to find x than would a binary search? (A) It will never use fewer comparisons. (B) When x is in the middle position of the array (C) When x is very close to the beginning of the array (D) When x is very close to the end of the array (E) When x is not in the array

An algorithm for searching a large sorted array for a specific value x compares every third item in the array to x until it finds one that is greater than or equal to x. When a larger value is found, the algorithm compares x to the previous two items. If the array is sorted in increasing order, which of the following de- scribes all cases when this algorithm uses fewer comparisons to find x than would a binary search? (A) It will never use fewer comparisons. (B) When x is in the middle position of the array (C) When x is very close to the beginning of the array (D) When x is very close to the end of the array (E) When x is not in the array

Database System Concepts

7th Edition

ISBN:9780078022159

Author:Abraham Silberschatz Professor, Henry F. Korth, S. Sudarshan

Publisher:Abraham Silberschatz Professor, Henry F. Korth, S. Sudarshan

Chapter1: Introduction

Section: Chapter Questions

Problem 1PE

See similar textbooks

Similar questions

1 a. What is the largest number of key comparisons made by binary search in searching for a key in the following array? 3 14 27 31 39 42 55 70 74 81 85 93 98 b. List all the keys of this array that will require the largest number of key comparisons when searched for by the binary search? c Find the average number of key comparisons made by binary search in a successful search in this array. (Assume that each key is searched for with the same probability.) d. Find the average number of key comparisons made by binary search in an unsuccessful search in this array. (Assume that searches for keys in each of the 14 intervals formed by the array's element are equally likely )
After two passes of a sorting algorithm, the following array: 80 72 66 44 21 33 has been rearranged as shown below 21 33 80 72 66 44 Which sorting algorithm is being used (straight selection, bubble, or straight insertion)? Defend your answer
Have a look at the array below. We are trying to do quicksort on this array to sort it in ascending order. We wrote an algorithm that always takes the middle element as pivot. How the array will look like after first iteration(write in this format: 11,12,13,14,15)Array: 525 76 980 290 38 77 746 266 375 . Show the simulation in handwritten paper. Which sorting algorithm (Insertion, Merge, Quick) perform same in all (best, average and worst case) ?
In each of the following questions, you are given an input array A with n elements, where n is a very largepositive integer. You will then compare two sorting algorithms and justify which of the two algorithmsis faster in sorting this array A. In your responses, you must clearly explain which of the two algorithms runs faster. Make sure yourigorously justify your answer, carefully proving whether each algorithm is O(n), O(n log n), or O(n2). (a) Let A = [n, n -1, n - 2, . . . . 3, 2, 1] be an array where the rst n positive integers are listed indecreasing order.Determine whether Heapsort or Quicksort sorts this array faster.For this question, assume the Quicksort pivot is always the right-most element. (b) Let A be an array, where each of the n elements is a randomly chosen digit between 0 and 9.For example, if n = 12, this array could be A = [3, 5, 1, 0, 5, 7, 9, 2, 2, 8, 8, 6].Determine whether Counting Sort or Merge Sort sorts this array faster.
Suppose an array sorted in ascending order is rotated at some pivot unknownto you beforehand. (i.e., 0 1 2 4 5 6 7 might become 4 5 6 7 0 1 2).Find the minimum element. The complexity must be O(logN)You may assume no duplicate exists in the array."""def find_min_rotate(array): """ Finds the minimum element in a sorted array that has been rotated. """ low = 0 high = len(array) - 1 while low < high: mid = (low + high) // 2 if array[mid] > array[high]: low = mid + 1 else: high = mid return array[low] def find_min_rotate_recur(array, low, high): """ Finds the minimum element in a sorted array that has been rotated. """ mid = (low + high) // 2 if mid == low:.
: In searching an element in an array, linear search can be used, even though simple to implement, but not efficient, with only O(n) time complexity. Assuming the array is already in sorted order, modify the search function below, using a better algorithm, so the average time complexity for the search function is O(log n). include <iostream> using namespace std; int search(int al), int s, int v) { 1/ Modify below codes. for (int i = 0; i <s; i++) { if (a[i] = v) return i; return -1; int main() { int intArray:10] = { 5, 7, 8, 9, 10, 12, 13, 15, 20, 34); // Search for element '12' in 10-elements integer array. cout << search(intArray, 10, 12); // '5' will be printed out. // Search for element '35' in 10-elements integer array. cout << search(intArray, 10, 35); // '-1' will be printed out. // Index '-l' means that the element is not found. return 0;
1. Consider the algorithm for the sorting problem that sorts an array by counting,for each of its elements, the number of smaller elements and then uses thisinformation to put the element in its appropriate position in the sorted array:ALGORITHMComparisonCountingSort(A[0..n − 1])//Sorts an array by comparison counting//Input: Array A[0..n//Output: Array S[0..n− 1] of orderable values− 1] of A’s elements sorted// in nondecreasing orderfor i ← 0 to nCount− 1 do[i]←0for i ← 0 to n − 2 dofor j ← i +1 to n − 1 doif A[i] < A[j ]Count[j ]← Count[j ] + 1else Count[i]← Count[i] + 1for i ←0 to n−1 doS[Count[i]]←A[i]return Sa. Apply this algorithm to sorting the list 60, 35, 81, 98, 14, 47.b. Is this algorithm stable?c. Is it in-place?
Please justify your answer: Some sorting algorithms require extra space, apart from the space needed for the original array that needs to be sorted. Which one of the following statements on the space usage of sorting algorithms is correct? a.) A Heapsort for sorting an array of size N requires an amount of extra space proportional to N. b.) Insertion Sort for sorting an array of size N requires an amount of extra space proportional to N. c.) Merge sort for sorting an array of size N requires an amount of extra space proportional to N. d.) Quicksort for sorting an array of size N requires an amount of extra space proportional to N. e.) None of the above
s algorithm for finding all occurrences of a sequence in anothersequence using the suffix array of the latter sequence can be implemented inPerl in a straightforward way, as shown in the following Perl script. Recallthat the suffix array of a sequence of length n will be a permutation of arraypositions 0, 1, . . . , n − 1, because Perl arrays do not start with position 1 but,rather, with position 0.
Plot the result of (given) selectionsort(A) when A is a perfectly sorted and contains randoms integers ,0 to 100 inclusive, for array sizes n = 2,4,8,16,..1024. please provide code for A and generating the plot for each doubling array, as well as the resulting plot. def selectionsort(A): for i in range(len(A)): min_idx = i for j in range(i + 1, len(A)): if A[min_idx] > A[j]: min_idx = j A[i], A[min_idx] = A[min_idx], A[i] return A
Binary Search algorithm has an element given in sequential arrays.We have seen that at the O (logN) time complexity. We saw in the lessonThe algorithm determines whether a given element exists in sequential but non-element repetitive arraysand returns the index if the element exists in the array, and -1 if it does not. This time, againIn an array that is given sequentially, but can contain element repeats, there is a given element andthe lowest value eye (if any) containing that element.Since we assume that there may be the same valued elements in the eye, one of them has the indexwe want to know), otherwise we can use the algorithm of the binary search function that returns -1 as pseudocode.write.
Please help me with this algorithm question. suppose we modified the QuickSort algorithm such that we run InsertionSort on the first 10% of A in the Partitionmethod. You may assume the selection of the pivot will be the last element in the range[p, r]. What would be the best and worst case running time of this new algorithm? Explainyour reasoning. // quickSort() method for integer array public void quickSort(int[] A, int p, int r) { if(p < r) { int q = partition(A, p, r); quickSort(A, p, q - 1); quickSort(A, q + 1, r); } } // partition() method for integer array public int partition(int[] A, int p, int r) { int x = A[selectPivot(A, p, r)]; int i = p - 1; for(int j = p; j < r; j++) { if(order) { if(A[j] > x) { i = i + 1; exchange(A, i, j); } } else { if(A[j] <= x) {…