Moe, Larry and Curly have just purchased three new computers and use three different algorithms' to sort lists: T(n) Search Algorithm Linear Search Comparisons / sec Moe 50 (le Larry Curly Optimal Chunk Search 2/n Binary Search 1 log2 n where T(n) is the number of comparisons it takes, in the worst case, to sort a list of size n. How large must n be to ensure that, for every list, ... i Curly's computer sorts faster than Moe's? ji Larry's computer sorts faster than Moe's?

Moe, Larry and Curly have just purchased three new computers and use three different algorithms' to sort lists: T(n) Search Algorithm Linear Search Comparisons / sec Moe 50 (le Larry Curly Optimal Chunk Search 2/n Binary Search 1 log2 n where T(n) is the number of comparisons it takes, in the worst case, to sort a list of size n. How large must n be to ensure that, for every list, ... i Curly's computer sorts faster than Moe's? ji Larry's computer sorts faster than Moe's?

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

Consider a Binary Search Algorithm that performs a search for the number 48 within the following unsorted list. Using paper and pencil, show the detailed steps for that search algorithm until 48 is found. You must use bubble sort if need it.1019134353415604870
You, Alice and Bob are working on recursive search algorithms and have been studying a variant of binary search called trinary search. Alice has created the following pseudocode for this algorithm: TSearch (A[a...b], t) If a b return -1 Let p1= a + Floor ((b-a)/3) If A[p1] t return p1 If A[p1]> t return TSearch (A[a...p1-1], t) Let p2 = a + Ceiling (2(b-a)/3) If A[p2] = t return p2 If A[p2]> t return TSearch (A [p1+1...p2-1],t) Return TSearch (A [p2+1...b],t) EndTSearch a) State a recurrence relation that expresses the number of operations carried out by this recursive algorithm when called on an input array of size n. b) Bob has heard that trinary search is no more efficient than binary search when considering asymptotic growth. Help prove him correct by using induction to show that your recurrence relation is in (log₂ n) as well. i. Split the tight bound into and upper (big-O) and lower (big-1). ii. For each bound select a function from (log₂ n) to use in your proof, like alog₂ n or…
Given these 8 numeric values to be sorted using the recursive Mergesort algorithm: 92 63 24 18 69 27 64 43 The list that will be passed to the first call of the Mergesort algorithm will be the entire list of values above. Show the list that will be passed to the 5th call of the Mergesort algorithm.
AssuAssume we want to analyze empirically 4 variants of the Quicksort algorithm by varying the selection of the pivot and the recursive call as follows: ● Try the following values when selecting a pivot: - Pick the last element as pivot - Pick a random element as pivot ● Do not make a recursive call to QuickSort when the list size falls below a given threshold, and use Insertion Sort to complete the sorting process instead. Try the following values for the threshold size: - Log2(N) - Sqrt(N) Therefore, you are asked: a. (12 points) Write the java code for the 4 Quicksort implementations. b. (5 points) Write a driver program that allows you to measure the running time in milliseconds of the 4 implementations for N = 10000, 20000, 40000, 80000 and 160000. For each data size N, generate a random list of N random integers ranging from 1 to 107 and use the same list to measure the running time of the 4 implementations. Present the results in the following table:me we want to analyze…
True/False 3. Binary search is an n log n algorithm.
Implement the following two sorting algorithms in a program called p3.py. Write two separate functions for these algorithms. Both functions must take a list of integers as the input parameter.1) Bogosort: first shuffle the list argument (i.e., randomize the positions of every element) and then check to see if the result is in sorted order. If it is, the algorithm terminates successfully and returns True, but if it is not then the process must be repeated.2) Bozosort: choose two elements in the list at random, swap them, and then check if the result is in sorted order. If it is, the algorithm terminates successfully and returns True, but if it is not then the process must be repeated.Write a main() function and call both sorting functions using the same list as their arguments. The list can be of any size (try a small list first). Does any of your algorithms terminate? If yes, count the number of iterations it uses to sort the list. Does it always use the same number of repetitions? If…
1. You, Alice and Bob are working on recursive search algorithms and have been studying avariant of binary search called trinary search. Alice has created the following pseudocodefor this algorithm:TSearch(A[a...b], t)If a > b return -1Let p1 = a + Floor((b - a)/3)If A[p1] = t return p1If A[p1] > t return TSearch(A[a...p1-1],t)Let p2 = a + Ceiling(2(b - a)/3)If A[p2] = t return p2If A[p2] > t return TSearch(A[p1+1...p2-1],t)Return TSearch(A[p2+1...b],t)EndTSearcha) State a recurrence relation that expresses the number of operations carried out bythis recursive algorithm when called on an input array of size n.b) Bob has heard that trinary search is no more efficient than binary search whenconsidering asymptotic growth. Help prove him correct by using induction to showthat your recurrence relation is in Θ(log2 n) as well.i. Split the tight bound into and upper (big-O) and lower (big-Ω).ii. For each bound select a function from Θ(log2 n) to use in your proof, likea log2 n or a…
A binary search only works if the values in the list are sorted. A bubble sort is a simple way to sort entries. The basic idea is to compare two adjacent entries in a list-call them entry[j] and entry[j+1]. If entry[j] is larger, then swap the entries. If this is repeated until the last two entries are compared, the largest element in the list will now be last. The smallest entry will ultimately get swapped, or "bubbled" up to the top. The algorithm could be described in C as: last = num; while (last > 0) { pairs = last – 1: for (j = 0; j entry (j+1] { temp = entry[il: entryli] = entrylj+1]; entrylj+1] = temp; last = i: } } Here, num is the number of entries in the list. Write an assembly language program to implement a bubble sort algorithm, and test it using a list of 8 elements. Each element should be a halfword in length. Please show your code works with the Keil tools or VisUAL, by grabbing a screen shot with your name somewhere on the screen.
16. Given an n-element array with n > 100, is it possible to find an algorithm that can find an element that is neither the maximum nor the minimum with fewer than 10 comparisons? (a) yes (b) no
There exist sorting algorithms which can sort any list with N elements in O(N log N) time. True False
Implement algorithm FindMax(L) pre-cond: L is an array of n values. post-cond: Returns an index with maximum value.
Bubble sort algorithm takes O(n²) time to sort the given array. A modified bubble sort is implemented with an extra flag. If the list is already sorted, then the extra flag is used to skip the remaining passes. What is best case complexity of the above modified bubble sort?