QuestionWhich of the following statements about mergesort are true? Unless otherwise specified, assume that mergesort refers to the pure recursive (top-down) version of mergesort (with nooptimizations), using the merging subroutine described in lecture.AnswerMark all that apply.OThe number of compares to bottom-up mergesort an array depends only on the length of the array n (and not on the keys or order of the keys in the array).O Mergesort is a stable sorting algorithm.Suppose that n is a power of 2. For any array of n distinct keys, top-down mergesort and bottom-up mergesort compare exactly the same pairs of keys (but possibly in a different order).OMergesort uses only a logarithmic amount of space (other than the input array).OIt is possible to design a compare-based algorithm to merge any two sorted arrays, each of length n, with no more than 3/2 n compares.

Merge sort is an efficient sorting algorithm which is based on divide and conquer rule. Here is the…

Answered: Juestion which of the following…

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

Answer the given question with a proper explanation and step-by-step solution. Heapsort has heapified an array to: 94 85 80 22 49 55 77 and is about to start the second for loop.What is the array after the first iteration of the second for loop?
Consider the following scenario in which recursive binary search could be advantageous. What would you do if you found yourself in such a situation? What is the first requirement that a recursive binary search must satisfy?
Consider the use of the recursive MergeSort algorithm to sort a sequence of n elements. Approximate the largest number of pushes (without corresponding pops) to the stack that will existing at any time during the execution of this algorithm. In other words, approximately how deep will the stack become as the MergeSort algorithm sorts an n-element sequence? You must justify your answer.
Implement the three improvements to mergesort Add a cutoff for small subarrays, test whether the array is already in order, and avoid the copy by switching arguments in the recursive code.
By hand, apply both quicksort to the sequence A,L,G,O,R,I,T,H,M. and draw the tree of recursive calls made.
In this programming assignment, you are expected to design an experimental study for thecomparison between Hoare’s partitioning and Lomuto’s partitioning in Quicksort algorithm.You must implement the recursive Quicksort algorithm using two partitioning algorithms inJava. You must design the experiments for the comparison of two algorithms both theoreticallyand empirically. You must write a detailed report including the pseudo-code of the algorithms,the time complexity of the algorithms, the experimental design, and your results. You canprovide some plots (scatter, line etc.) to illustrate your results.
with n=6 and A=(3,5,4,1,3,2). Draw the corresponding walkthrough as shown in P.173. No subsequent recursive call to Quicksort is needed.
Implement a quicksort with a sample size of 2k 1. Sort the sample first, then have the recursive procedure partition on the sample's median and shift the two halves of the rest of the sample to each subarray so that they may be utilised in the subarrays without having to be sorted again. This algorithm is known as samplesort. Put into practise a quicksort based on a 2k sample. The sample should be sorted first, after which you should set up the recursive procedure to split the sample based on its median and to shift the two halves of the remaining sample to each subarray so they can be utilised in the subarrays without needing to be sorted again. The name of this algorithm is samplesort.
Using Java implementations presented in the algorithms below.Practice Mergesort algorithm with Comparable Java objects whose class definition implements Java's Comparable interface. For example, using sample Comparable Student objects or Comparable Java class objects of your own implementation. Algorithm: void mergesort(E[] A, E[] temp, int l, int r) { int i, j, k, mid = (l+r)/2; if (l == r) return; // List has one element if ((mid-l) >= THRESHOLD) mergesort(A, temp, l, mid); else inssort(A, l, mid-l+1); if ((r-mid) > THRESHOLD) mergesort(A, temp, mid+1, r); else inssort(A, mid+1, r-mid); // Do merge. First, copy 2 halves to temp. for (i=l; i<=mid; i++) temp[i] = A[i]; for (j=1; j<=r-mid; j++) temp[r-j+1] = A[j+mid]; // Merge sublists back to array for (i=l,j=r,k=l; k<=r; k++) if (temp[i].compareTo(temp[j])<0) A[k] = temp[i++]; else A[k] = temp[j--];}
We learned in this lesson that Merge Sorts are recursive. One of the favorite topics that College Board likes to ask is how many times a recursive method is called. With that in mind, let’s figure out how many times our recursive method is called for a given merge sort. For this exercise, you are given the mergeSort and the makeRandomArray helper methods. Using the static count variable, add an incrementer in the mergeSort method to count how many times it is called. Then, in the main method, create a random array of sizes 100, 1000, 10k, and 100k. Run the array through the sort and print out the results of the counter. Don’t forget to reset the counter between runs! You should pay attention to the pattern that you see. Does this pattern surprise you? Sample Output Total Recursive calls for 100: ** Results Hidden ** Total Recursive calls for 1000: ** Results Hidden ** Total Recursive calls for 10000: ** Results Hidden ** Total Recursive calls for 100000: ** Results Hidden ** Challenge:…
Given the following function, what happens if a[] contains just one element that doesn't match val? int binarySearch(int a[], int first, int last, int val){ if (first > last) return -1; int middle = (first + last) / 2; if (a[middle] == val) return middle; if (a[middle] < val) return binarySearch(a, middle+1, last, val); else return binarySearch(a, first, middle-1, val);} Group of answer choices binarySearch never calls itself again and terminates (recursion never happens) binarySearch calls itself once then terminates (recursion happens once) binarySearch calls itself twice then terminates (recursion happens twice) binarySearch calls itself 3 times then terminates (recursion happens 3 times)
Consider the following recursive definition of list reversal. For a list L, rev(L) is defined: rev([]) = []rev(x : L) = rev(L) + [x] Please prove by induction on L that concatenation is left cancellative: L+M = L+N implies M = N. Please prove by induction on L that rev(rev(L)) = L for all lists L. Please prove by induction on L that rev(L + M ) = rev(M ) + rev(L) for all lists L and M . (Can utilize fact that concatenation = associative) Using 1, 2, and 3 to prove that concatenation is right cancellative as well: L + N = M + N implies L = M.

SEE MORE QUESTIONS

Recommended textbooks for you

Database System Concepts

Computer Science

ISBN:

9780078022159

Author:

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

Publisher:

McGraw-Hill Education

Starting Out with Python (4th Edition)

Computer Science

ISBN:

9780134444321

Author:

Tony Gaddis

Publisher:

PEARSON

Digital Fundamentals (11th Edition)

Computer Science

ISBN:

9780132737968

Author:

Thomas L. Floyd

Publisher:

PEARSON

Database System Concepts

Computer Science

ISBN:

9780078022159

Author:

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

Publisher:

McGraw-Hill Education

Starting Out with Python (4th Edition)

Computer Science

ISBN:

9780134444321

Author:

Tony Gaddis

Publisher:

PEARSON

Digital Fundamentals (11th Edition)

Computer Science

ISBN:

9780132737968

Author:

Thomas L. Floyd

Publisher:

PEARSON

C How to Program (8th Edition)

Computer Science

ISBN:

9780133976892

Author:

Paul J. Deitel, Harvey Deitel

Publisher:

PEARSON

Database Systems: Design, Implementation, & Manag…

Computer Science

ISBN:

9781337627900

Author:

Carlos Coronel, Steven Morris

Publisher:

Cengage Learning

Programmable Logic Controllers

Computer Science

ISBN:

9780073373843

Author:

Frank D. Petruzella

Publisher:

McGraw-Hill Education

SEE MORE TEXTBOOKS