Please answer the following question attached below(use java ) and also add necessary comments for understanding 1. With the partial implementation of the "Merge-Sort" algorithm (shown below),namely, merge() and mergeSort(), build a test program that sorts an unsorted arrayof the size of 20. You may need Queue, LinkedQueue or any other classes andinterfaces to import./** Merge contents of arrays S1 and S2 into properly sized array S. */public static void merge (K[] S1, K[] s2, K[] S, comparator comp) {int i = 0, j = 0;while (i + j < S.length) {if (j == S2.1length || (i < S1.length && comp.compare(S1[i], S2[j]) < 0))S[i+j] = S1[i++];else// copy ith element of S1 and increment iS[i+j] = S2[j++];}}/** Merge-sort contents of array S. */public static void mergeSort (K[] S, Comparator comp) {int n = S.length;if (n < 2) return;// divideint mid = n/2;// copy jth element of S2 and increment j// array is trivially sorted// copy of first half// copy of second halfK[] s1 = Arrays.copy0fRange (S, 0, mid);K[] s2 = Arrays.copy0fRange (S, mid, n);// conquer (with recursion)mergeSort(S1, comp);mergeSort(S2, comp);// merge resultsmerge(S1, S2, S, comp);// sort copy of first half// sort copy of second half// merge sorted halves back into original

1. With the partial implementation of the "Merge-Sort" algorithm (shown below), namely, merge( ) and mergeSort(), build a test program that sorts an unsorted array of the size of 20. You may need Queue, LinkedQueue or any other classes and interfaces to import. /** Merge contents of arrays S1 and S2 into properly sized array S. */ public static void merge(K[] s1, K[] S2, K[] s, Comparator comp) { int i = 0, j = 0; while (i + j < S.length) { if (j == S2.1ength || (i < s1. length && comp.compare(S1[i], S2[j]) < e)) S[i+j] = S1[i++]; else // copy ith element of S1 and increment i // copy ith element of S2 and increment j S[i+j] = S2[j++]; } } /** Merge-sort contents of array S. */ public static void mergeSort (K[] S, Comparator comp) { int n = S.length; if (n < 2) return; // divide int mid = n/2; K[] s1 = Arrays.copy0fRange (S, e, mid); K[] s2 = Arrays.copy0fRange (S, mid, n); // conquer (with recursion) mergeSort(S1, comp); mergeSort(S2, comp); // merge results merge (S1, S2, s, comp); // array is trivially sorted // copy of first half // copy of second half // sort copy of first half // sort copy of second half // merge sorted halves back into original

1. With the partial implementation of the "Merge-Sort" algorithm (shown below), namely, merge( ) and mergeSort(), build a test program that sorts an unsorted array of the size of 20. You may need Queue, LinkedQueue or any other classes and interfaces to import. /** Merge contents of arrays S1 and S2 into properly sized array S. */ public static void merge(K[] s1, K[] S2, K[] s, Comparator comp) { int i = 0, j = 0; while (i + j < S.length) { if (j == S2.1ength || (i < s1. length && comp.compare(S1[i], S2[j]) < e)) S[i+j] = S1[i++]; else // copy ith element of S1 and increment i // copy ith element of S2 and increment j S[i+j] = S2[j++]; } } /** Merge-sort contents of array S. */ public static void mergeSort (K[] S, Comparator comp) { int n = S.length; if (n < 2) return; // divide int mid = n/2; K[] s1 = Arrays.copy0fRange (S, e, mid); K[] s2 = Arrays.copy0fRange (S, mid, n); // conquer (with recursion) mergeSort(S1, comp); mergeSort(S2, comp); // merge results merge (S1, S2, s, comp); // array is trivially sorted // copy of first half // copy of second half // sort copy of first half // sort copy of second half // merge sorted halves back into original

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

implement merge-sort multithreadA is an array and p and q indexes of the array such as you gonna sort the sub-array A[p..r]. B is a sub-array which willbe populated by the sort.A call to p-merge-sort(A,p,r,B,s) sorts elements from A[p..r] and put them in B[s..s+r-p]
Write java code to do the following: Implement the Quicksort algorithm for both generic lists and generic arrays public static <T extends Comparable<T>> void quickSort(final List<T> list, final Comparator<T> comparator) {...} public static <T extends Comparable<T>> void quickSort(final T[] array, final Comparator<T> comparator) {...}
Perform the previous project, but use a doubly linked list. Moreover, your implementation of remove(i) should make the fewest number of pointer hops to get to the game entry at index i. You need to implement the doubly linked list yourself. Problem 3!!
Implements clone which duplicates a list. Pay attention, because if there are sublists, they must be duplicated as well. Understand the implementation of the following function, which recursively displays the ids of each node in a list def show_ids(M, level=0): k = M.first_node while k is not None: print(" "*2*level, id(k)) if (str(k.value.__class__.__name__) == str(M.__class__.__name__)): show_ids(k.value, level+1) k = k.next W=L2(Node(10, Node(L2(Node(14, Node(15, Node(L2(Node(16, Node(17))))))), Node(20, Node(30)))) )show_ids(W) Develop your solution as follows: - First copy the nodes of the current list (self) - Create a new list with the copied nodes - Loop through the nodes of the new list checking the value field - If this field is also a list (use isinstance as in the show_ids function) then it calls clone on that list and substitutes the value. Complete the code: def L4(*args,**kwargs): class L4_class(L):…
Write code to remove duplicates from an unsorted linked list.FOLLOW UPHow would you solve this problem if a temporary buffer is not allowed?
Implement two out of three of the basic sorting algorithms - Bubble Sort, Selection Sort, and Insertion Sort - in a generic List. Initial code to be completed: #include <iostream>#include "linkedlist.h" void bubbleSort(List*);void selectionSort(List*);void insertionSort(List*); /** * This activity is focused on using Arrays and Linked Lists as two different * implementations of List. It follows that you are only to use the methods of * List and not of the specific array or linkedlist. */int main(void) { // WARNING! Do not modify main method! // Doing so will nullify your score for this activity. char li; cin >> li; List* list; if (li == 'A') { list = new ArrayList(); } else { list = new LinkedList(); } int length; cin >> length; int input; for (int i = 0; i < length; i++) { cin >> input; list->add(input); } char sym; cin >> sym; int arg1; switch (sym) {…
Implement the function below void swap(int pos1, int pos2) {} Inital code to be completed: class LinkedList : public List { node* head; node* tail; int index; node* create_node(int num) { node* n = (node*) malloc(sizeof(node)); n->element = num; n->next = NULL; return n; } public: LinkedList() { index = 0; head = NULL; tail = NULL; } int add(int num) { addTail(num); return index; } int get(int pos) { node* currnode = head; int count =0; while (currnode != NULL){ count++; if (count == pos){ return currnode -> element; }else{ currnode = currnode -> next; } } return -1; } int size() { return index; } void swap(int pos1, int pos2) { } // WARNING!…
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++]; } } }
Write a version of bottom-up mergesort that takes advantage of order in the array by proceeding as follows each time it needs to find two arrays to merge: find a sorted subarray (by incrementing a pointer until finding an entry thatis smaller than its predecessor in the array), then find the next, then merge them. Analyze the running time of this algorithm in terms of the array size and the number of maximal increasing sequences in the array.
Write a program using C++ that uses a hashing algorithm to create a list of students present in a class. Consider the student numbers as keys, while implementing rotation, fold boundary methods and linear probing (include modulo division if necessary) for an array-based list of length 1000. After creating the list, allow the user to search for the name of a student and report its student number.
Please develop well-documented pseudo code that finds all consecutive similar elements of a given array (of any size n) by using either a stack or a queue. The code must display the start indices where the values start to repeat, as well as the values of these elements. For instance, given the following array A: (22, 9, 61,61, 61, 21, 0, 9, 9, 9, 9, 35, 81,81, 9, 5, 5), the code should find and display something similar to the following (pls notice that this is just an example. The solution must not refer to this particular example): Value 61 is repeated 3 times starting at Index 2 Value 9 is repeated 4 times starting at Index 7Value 81 is repeated 2 times starting at Index 12Value 5 is repeated 2 times starting at Index 15 a) Briefly justify the motive(s) behind your design. b) What is the Big-O time complexity of your solution? Explain clearly how you obtained such complexity. c) What is the Big-Ω time complexity of your solution? Explain clearly how you obtained such complexity. d)…
Consider the implementation of the Ordered Linked list class, implement the following functions as part of the class definition: ▪ index(item) returns the position of item in the list. It needs the item and returns the index. Assume the item is in the list.   ▪ pop() removes and returns the last item in the list. It needs nothing and returns an item. Assume the list has at least one item.   ▪ pop_pos(pos) removes and returns the item at position pos. It needs the position and returns the item. Assume the item is in the list.   ▪ a function that counts the number of times an item occurs in the linked list ▪ a function that would delete the replicate items in the linked list (i.e. leave one occurrence only of each item in the linked list) Your main function should do the following: ▪ Generate 15 random integer numbers in the range from 1 to 5.▪ Insert each number (Item in a node) in the appropriate position in a linked list, so you will have a sorted linked list in ascending order.▪…