2. Suppose the function MergeSort( Vis a recursive implementation of the merge sort algorithm, which takes as input an integer array A. How many times isMergeSort( ) recursively called, if A is of size n? Answer: SelectT SelectOlnlogn3. How many times is the Merge routine called in total,O(1)Oln 2)nswer. ISelect ]

2. Suppose the function MergeSort( O s a recursive implementation of the merge sort algorithm, which takes as input an integer array A. How many tìmes MergeSort() recursively called, if A is of size n? Answer: I Select| Select Ofnlogn) 3. How many times is the Merge routine called in total, O(1) On^2) swer. Select]

2. Suppose the function MergeSort( O s a recursive implementation of the merge sort algorithm, which takes as input an integer array A. How many tìmes MergeSort() recursively called, if A is of size n? Answer: I Select| Select Ofnlogn) 3. How many times is the Merge routine called in total, O(1) On^2) swer. Select]

C++ Programming: From Problem Analysis to Program Design

8th Edition

ISBN:9781337102087

Author:D. S. Malik

Publisher:D. S. Malik

Chapter16: Searching, Sorting And Vector Type

Section: Chapter Questions

Problem 16SA

See similar textbooks

Similar questions

Present an example of walking through the merge sort or the quick sort algorithm (your choice) This is an algorithm tracing activity, not a coding exercise. Do not post any code or code output. Post the following for merge sort: Start with an unordered list of at least NINE elements. List all the recursive calls that would be made to sort the list, going forward. Show which pair of sub-lists will be merged each time, going back. Show the ordering of the sub-list after each recursive call returns. Post the following for quick sort: Start with an unordered list of at least NINE elements. State what element will be the pivot value (use only low index or median-of-three). List all the recursive calls that would be made to sort the list. Show the ordering of the sub-list after each recursive call returns.
please answer the following definitions: A programming construct that is defined within a programming language to store a collection of data is a(n)____ Which of the following is not a characteristic of the merge sort algorithm? It can be implemented using recursion. It is stable. It exploits the divide-and-conquer problem-solving technique. Its worst-case time complexity is O(n2). Assuming s1 is a string object and cs1 is an array of characters, which of the following is a valid statement? cs1 = s1; strcpy(cs1,s1); cs1 = s1.c str(); s1 = cs1; If class A is a friend class of B, which of the following is true? All member-functions of class A are friends of class B All member-functions of class B are friends of class A All friend functions of class A can access private variables of class B The accessor and mutator functions of class B cannot be used in class A Which of the following represents the proper declaration of a function that returns the maximum of two…
Java Merge Sort but make it read the data 12, 11, 13, 5, 6, 7 from a file not an array /* Java program for Merge Sort */ class MergeSort { // Merges two subarrays of arr[]. // First subarray is arr[l..m] // Second subarray is arr[m+1..r] void merge(int arr[], int l, int m, int r) { // Find sizes of two subarrays to be merged int n1 = m - l + 1; int n2 = r - m; /* Create temp arrays */ int L[] = new int[n1]; int R[] = new int[n2]; /*Copy data to temp arrays*/ for (int i = 0; i < n1; ++i) L[i] = arr[l + i]; for (int j = 0; j < n2; ++j) R[j] = arr[m + 1 + j]; /* Merge the temp arrays */ // Initial indexes of first and second subarrays int i = 0, j = 0; // Initial index of merged subarray array int k = l; while (i < n1 && j < n2) { if (L[i] <= R[j]) { arr[k] = L[i];…
Given the following non-recursive implementation of depth-first search: A. Complete the implementation of depth-first search by filling in the TODO sections with the appropriate C++ code. Remember to: Print out each node you visit. Visit each node exactly once. B. What is the purpose of stack<string> q? C. What is the purpose of set<string> v?
Create an algorithm for Merge Sort, determine the time complexity, and create a c++ implementation of the algorithm
Write a recursive version of this code. one in which n is divided by two. public static <T extends Comparable<T>> void MergeSorting(T[] arr) {T[] tep = (T[]) new Comparable[arr.length];MergeSorting(arr, tep, 0, arr.length - 1);}//Recursive helper method for the merge sort algorithm.//arr The array to sort//tep Temporary array for merge operation//start Index of the left end of the region to sort //end Index of the right end of the region to sort. private static <T extends Comparable<T>> void mergeSort(T[] arr, T[] tep, int start,int end) {if (start >= end) {return;}int middle = (left + right) / 2;MergeSorting(arr, tep, start, middle); // first halfMergeSorting(arr, tep, middle + 1, end); //second halfMerge(arr, tep, start, middle, end);}private static <T extends Comparable<T>> void Merge(T[] arr, T[] tep, int start, int middle,int end) {for (int i = start; i <= end; i++) {tep[i] = arr[i];//adds the arry to tep}int a = 0;int b = middle + 1;for…
Here is my homwork problem: Problem 3. In the following array of C-strings char* names[] = { “DEF”, “BBB” , “EE”, “AA”, “CAB”, “AAA”, “DDDD”, “BBB”, “FFFF”, “CCCC”}; char* favoriteName= “AA”; Use generic binary search both iterative and recursive to find the favoriteName in the names array. If char names[][5] = { “DEF”, “BBB” , “EE”, “AA”, “CAB”, “AAA”, “DDDD”, “BBB”, “FFFF”, “CCCC”}; char* favoriteName= “AA”; What will be your call for search and explain any difference? Now dynamically allocate char**names and copy with all the names above and dynamically allocate char*favoriteName and copy with “AA” Make a call for the search _______________ *I am using C programming language for this problem* I made some code with iterative and recursive binary search functions, but only the iterative one finds the favorite name. Can you let me know what is wrong with my recursive binary search function as well as how to get it to work with the double array names[][5]? Here is my code:…
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.
(IN C++) Write a program to implement Quicksort. Also implement one of the slow sorts (Bubble, Insertion...). After you have tested both, generate a very large array (30,000 or more) of bytes and sort increasingly larger portions of the array (5000, 10000, ..., 30000) with both algorithms. Draw a graph of execution time versus number of elements for both algorithms. What are your conclusions? (IN C++) please.
Using c++ Create a program to satisfy the following problems: Set up a random experiment to test the difference between a sequential search and a binary search on a list of integers. Use the binary search functions given in the text (recursive and iterative). Generate a random, ordered list of integers and do a benchmark analysis for each one. What are your results? Can you explain them? Implement the binary search using recursion without the slice operator. Recall that you will need to pass the list along with the starting and ending index values for the sublist. Generate a random, ordered list of integers and do a benchmark analysis. Overload the cout operator (<<) for the hash table Map ADT implementation. Overload the cin operator (>>) for the hash table Map ADT implementation.
A. Compare insertion sort and merge sort on any aspect you can. B.For the list of numbers given below, which sort algorithm performs better, why? 110 25 40 52 65 73 84 90
Develop a merge implementation that reduces the extra space requirement to max(M, N/M), based on the following idea: Divide the array into N/M blocks of size M (for simplicity in this description, assume that N is a multiple of M). Then, (i) considering the blocks as items with their first key as the sort key, sort them using selection sort; and (ii) run through the array merging the first block with the second, then the second block with the third, and so forth.