please write the graph full code & write the complexity of its worst-casetime. Problem 3: Array ReversalWe have come through an old algorithm whose name indicates that it reverses the arrayelements; its pseudo-code was defined as follows: note n := A.length denotes the size ofthe array, number of items.Algorithm 2 REVERSE-ARRAY(A)s+ [), e +while s >0 A e < (n – 1) doswap (A[s], A[e])s + s – 1n-e te+1end whileImplement the algorith". m Python, and test itb Empirically, show the performance curve of the algorithm using time measurementsc Using the basics of the theoretical analysis, write the complexity of its worst-casetime.d Prove that the algorithm is actually correct

a. def swap(list, pos1, pos2): list[pos1], list[pos2] = list[pos2], list[pos1] return list…

We have come through an old algorithm whose name indicates that it reverses the array elements; its pseudo-code was defined as follows: note n := A.length denotes the size of the array, number of items. Algorithm 2 REVERSE-ARRAY(A) while s >0A e < (n – 1) do swap (A[s], A[e])

We have come through an old algorithm whose name indicates that it reverses the array elements; its pseudo-code was defined as follows: note n := A.length denotes the size of the array, number of items. Algorithm 2 REVERSE-ARRAY(A) while s >0A e < (n – 1) do swap (A[s], A[e])

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

: In searching an element in an array, linear search can be used, even though simple to implement, but not efficient, with only O(n) time complexity. Assuming the array is already in sorted order, modify the search function below, using a better algorithm, so the average time complexity for the search function is O(log n). include <iostream> using namespace std; int search(int al), int s, int v) { 1/ Modify below codes. for (int i = 0; i <s; i++) { if (a[i] = v) return i; return -1; int main() { int intArray:10] = { 5, 7, 8, 9, 10, 12, 13, 15, 20, 34); // Search for element '12' in 10-elements integer array. cout << search(intArray, 10, 12); // '5' will be printed out. // Search for element '35' in 10-elements integer array. cout << search(intArray, 10, 35); // '-1' will be printed out. // Index '-l' means that the element is not found. return 0;
1. Write an algorithm that applies right shift on one dimensional array (trace your algorithm on example array A: [0, 9, 2, 10, 3] and show the result of your trace steps as a table). *Dont use extra array while solving this problem *Just write algorithm do not write program in any other programming language
“A” array has a members and “B” array has b members which are sorted. I need an algorithm to find the k-th member in a new array which is a mix of “A” and “B”. The runtime must be O(log(a+b))
Fun with Sorting :Given the following array of numbers:8 2 3 9 10 1 4 6 7 5Show what the array looks like after each iteration of the following sorting algorithms:1) Bubble2) Selection3) Insertion4) MergesortOnly show the array contents with each algorithm. You do not need to show function callinstances if recursion is used or write any code. Just show the array at key iterations of thealgorithm. You can use your own words to describe them as well for more detail (but do notwrite any code).
Problem 2: Suppose you are given an integer array A of length n and some integer z. Write an algorithm that searches the array for two integers x and y such that x + y = z. The algorithm should return the pair (x, y) if it finds that and some reserved token "NONE" if two such integers do not exist. Your algorithm must run in O(n) time and O(n) space.
The following procedure sums up all the prefix of an array a into a vector p. The loop body has some unnecessary pointer dereference that affects the performance negatively. Remove those pointer dereference from the loop body and write down the resulting code. void pum(float a[], float p[], long n) { long i; p[0] = a[0]; for (i = 1; i
01... ""Implementation of the Misra-Gries algorithm.Given a list of items and a value k, it returns the every item in the listthat appears at least n/k times, where n is the length of the array By default, k is set to 2, solving the majority problem. For the majority problem, this algorithm only guarantees that if there isan element that appears more than n/2 times, it will be outputed. If thereis no such element, any arbitrary element is returned by the algorithm.Therefore, we need to iterate through again at the end. But since we have filtredout the suspects, the memory complexity is significantly lower thanit would be to create counter for every element in the list. For example:Input misras_gries([1,4,4,4,5,4,4])Output {'4':5}Input misras_gries([0,0,0,1,1,1,1])Output {'1':4}Input misras_gries([0,0,0,0,1,1,1,2,2],3)Output {'0':4,'1':3}Input misras_gries([0,0,0,1,1,1]Output None"""..
Java Insertion Sort but make it read the data 12, 11, 13, 5, 6 from a file not an array // Java program for implementation of Insertion Sort public class InsertionSort { /*Function to sort array using insertion sort*/ void sort(int arr[]) { int n = arr.length; for (int i = 1; i < n; ++i) { int key = arr[i]; int j = i - 1; /* Move elements of arr[0..i-1], that are greater than key, to one position ahead of their current position */ while (j >= 0 && arr[j] > key) { arr[j + 1] = arr[j]; j = j - 1; } arr[j + 1] = key; } } /* A utility function to print array of size n*/ static void printArray(int arr[]) { int n = arr.length; for (int i = 0; i < n; ++i) System.out.print(arr[i] + " "); System.out.println(); } // Driver method…
java ARRAY[] = [50, 11, 33, 21, 40, 50, 40, 40, 21] ARRAY[] = [11, 21, 33, 40, 50] ATTN : Further, please be reminded that you cannot use library functions to either sort and or perform the de-duplication operation. solve the problem in two ways (1) Implement the function in such a way that your solution solves the problem with O(n log2(n)) time complexity overall and O(n) space complexity. Here, n is the length of the list of input integers (array). I believe the sorting routine that can be used here is Merge Sort. Please state as code comment which sorting routine you are using, sort the arrray with that algorithm and solve the de-duplication problem thereafter. De-duplication part of the solution in itself must adhere to O(n) time and O(1) space bounds. we will not use any memory used by recursion. Important: Take the size of the input array from the User.Prompt user to input the integers in the array.PLEASE MAKE SURE TO EXPLAIN THE SORTING ALGORITHM AND DE-DUPLICATION…
Problem 3: Array Reversal We have come through an old algorithm whose name indicates that it reverses the array elements; its pseudo-code was defined as follows: note n := A.length denotes the size of the array, number of items. Algorithm 2 REVERSE-ARRAY(A) while s >0A e < (n – 1) do swap (A[s], A[e]) s + s – 1 e e +1 end while a) Implement the algorithm in Python, and test it b) Empirically, show the performance curve of the algorithm using time measurements c) Using the basics of the theoretical analysis, write the complexity of its worst-case time. d) Prove that the algorithm is actually correct
ALGO1(A)// A is an integer array, an index that starts at 11): for i=1 to n-1 do2): minIndex = findSmallest(A,i)3): exchange A[i] with A[minIndex] The sub-routine find the smallest(A, i) in Line 2, and returns the index of the smallest element in thesub-array A[i:n]Suppose the array below is provided as input to ALGO1 2 5 6 7 3 8 1 4 Fill in the Blanks At the end of the first iteration of the for loop (i.e. with i=1)1) a) the element at index 1 is : b) the element at index 4 is : c) the element at index 7 is :
For each of the algorithms unique 1 and unique2, which solves the element uniqueness problem, perform an experimental study on the same computer to determine: 1) What are these two algorithms doing here? Are they doing the same thing or not? 2) Which algorithm is faster and why? 3) Can you come up with an even faster algorithm? If so, what is it? /** Returns true if there are no duplicate elements in the array.*/ public static boolean uniquel (int[] data) { int n = data.length; for (int j 0; j