implement a parametrized version of mergesort that will allow us to choose how many parts the input array will be divided into. This method will take an integer array and integer K as inputs and produce one integer array as output. It will sort the input array by dividing it into K parts, recursively sorting those parts, and using the mergeAll method to merge the K sorted arrays into one sorted array. Implement the mergesortK method public static int[] mergesortK(int[] arr, int k) { return new int[] {-1}; }

implement a parametrized version of mergesort that will allow us to choose how many parts the input array will be divided into. This method will take an integer array and integer K as inputs and produce one integer array as output. It will sort the input array by dividing it into K parts, recursively sorting those parts, and using the mergeAll method to merge the K sorted arrays into one sorted array. Implement the mergesortK method public static int[] mergesortK(int[] arr, int k) { return new int[] {-1}; }

C++ Programming: From Problem Analysis to Program Design

8th Edition

ISBN:9781337102087

Author:D. S. Malik

Publisher:D. S. Malik

Chapter18: Stacks And Queues

Section: Chapter Questions

Problem 16PE: The implementation of a queue in an array, as given in this chapter, uses the variable count to...

See similar textbooks

Similar questions

Create a test program to test this MergeSort Program: package ArraySplit; import java.util.Arrays; public class ArraySplit { public static void mergeSort(int[] a, int n) { if (n < 2) { return; } int mid = n / 2; int[] l = new int[mid]; int[] r = new int[n - mid]; for (int i = 0; i < mid; i++) { l[i] = a[i]; } for (int i = mid; i < n; i++) { r[i - mid] = a[i]; } mergeSort(l, mid); mergeSort(r, n - mid); merge(a, l, r, mid, n - mid); } public static void merge(int[] a, int[] l, int[] r, int left, int right) { int i = 0, j = 0, k = 0; while (i < left && j < right) { if (l[i] <= r[j]) { a[k++] = l[i++]; } else { a[k++] = r[j++]; } } while (i < left) { a[k++] = l[i++]; } while (j < right) { a[k++] = r[j++]; } } }
we have proven that the computational time complexity of mergesort is O(n * log2n). Perhaps the time complexity of mergesort can be improved further by separating the array into three parts instead of two. Start by implementing a method called merge3. This method should take three sorted arrays as inputs and return a sorted array consisting of all elements of the three input arrays. public static int[] merge3(int[] a, int[] b, int[] c) { return new int[] {-1}; } * must be done in this format and in java
Implement a mergeUniqueValues(arr1, arr2) method. When passed two arrays of strings, it will return an array containing the strings that appear in either or both arrays in sorted order. And the returned array should have no duplicates. For example, if you have two string arrays: arr1: {“Bear”, “Elephant”,”Fox”}arr2: {“Panda”, “Elephant”,”Eagle”} Calling mergeUniqueValues(arr1, arr2) should return a merged and sorted array like: Bear, Eagle, Elephant, Fox, Panda
(a) Write a method public static void insert(int[] a, int n, int x) that inserts x in order among the first n elements of a, assuming these elements are arranged in ascending order. Do NOT use arraylists. x is the last element in a. n does not include x. (b) Using the insert method from Part (a), write a recursive implementation of Insertion Sort.
run the main() method of class Lab11D. Pls do the SWAPIN LAB 11D and below is the tester For example, A B C D E F should turn into D E F A B C. You should assume that the array list has an even number of elements (not necessarily 6). One solution is to keep removing the element at index 0 and adding it to the back. Each step would look like this: A B C D E F B C D E F A C D E F A B D E F A B C When you run the code, you will find that there is a lot of movement in the array list. Each call to remove(0) causes n - 1 elements to move, where n is the length of the array. If n is 100, then you move 99 elements 50 times, (almost 5000 move operations). That's an inefficient way of swapping the first and second halves. (Learn more about time complexity at the end of the lab). Come up with a better way in which you swap the elements directly. Hint: How do you swap the two elements A and D? A B C D E F D B C A E F D E C A B F D E F A B C Write pseudocode for this algorithm. Add…
Mergesort is a method that takes an integer array and returns a sorted copy of the same array. It first sorts the left half of the input array, then the right half of the input array, and finally merges the two sorted halves together into a sorted version of the input array. Implement the mergesort method public static int[] mergesort(int[] arr) { return new int[] {-1}; } *must be in this layout and done in java
For this problem I have a java code: import java.util.Arrays; import java.util.Scanner; public class MergeSortWeightedSumInversion { public static long merge(int arr[], int l, int mid, int r) { long weight = 0; int n1 = mid-l+1; int n2 = r-mid; int[] a = new int[n1]; int[] b = new int[n2]; for(int i = 0; i < n1; i++) { a[i] = arr[l+i]; } for(int i = 0; i < n2; i++) { b[i] = arr[mid+i+1]; } int i = 0, j = 0, k = l; while(i<n1 && j<n2) { if(a[i] <= b[j]) { arr[k] = a[i]; k++; i++; } else { weight += (a[i] + b[j]); arr[k] = b[j]; k++; j++; } } while(i<n1) { arr[k] = a[i]; k++; i++; } while(j<n2) { arr[k] = b[j]; k++; j++; } return weight; } public static long mergeSort(int arr[], int l, int r) { long weight = 0; if(l < r) { int mid = (l+r)/2; weight += mergeSort(arr, l, mid); weight += mergeSort(arr,mid+1,r); weight += merge(arr,l,mid,r); } return weight; } public static void main(String[] args) { Scanner scan = new Scanner(System.in); int n; n =…
Write a method quicksort that takes in an ArrayList of integers and returns them in ascending order, using a quicksort style of sorting. Remember that this style relies on choosing a pivot integer and breaking the set into values less than the pivot and more than the pivot, then repeating this process on each half until only single values are left, which are then put back together. public ArrayList<Integer> quickSort(ArrayList<Integer> list) { *code here*}
Write a java code that sorts a list of n items by dividing it into three sublistsof about n/3 items, sorting each sublist recursively and merging the threesorted sublists. Analyze your algorithm, and give the results under ordernotation.
Write a program that reads a list of 10 integers, and outputs those integers in reverse. For coding simplicity, follow each output integer by a space, including the last one. Then, output a newline. Ex: If the input is 2 4 6 8 10 12 14 16 18 20, the output is: 20 18 16 14 12 10 8 6 4 2 To achieve the above, first read the integers into an array. Then output the array in reverse. IN CORAL Please!
Write a Java method that takes two 2 dimensional int arrays (a and b) anda 2 dimensional boolean array (c) where all three arrays have the samesize. Your method should return an array (result) such that, if a particular element in c is true, then the corresponding (same indexed) elementin result must be the multiplication of the the corresponding elements ofa and b. If the element in c is false, then the the corresponding elementin result must be the negative of multiplication of the the correspondingelement in a and b.
Write a Java method using recursion that reorders an integer array in such a way that all the even values comes before the odd values Here is the code to start, fill in the missing part output should be 8 6 2 4 4 4 4 3 5 5 3 7 1 9