Consider this algorithm: a = 0 for i=0 to n for j=i+1 to n a = a + 2 The objective is to find the total number N of additions performed by the above algorithm to execute the statement a = a + 2. Inspire yourself from the analysis of the naive sorting algorithm to: I) Express N as a function of n. 2) Express the final value of a when the algorithm ends 3) Provide the best bound (growth) for N.

Consider this algorithm: a = 0 for i=0 to n for j=i+1 to n a = a + 2 The objective is to find the total number N of additions performed by the above algorithm to execute the statement a = a + 2. Inspire yourself from the analysis of the naive sorting algorithm to: I) Express N as a function of n. 2) Express the final value of a when the algorithm ends 3) Provide the best bound (growth) for N.

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

Below are a number of statements about sorting algorithms. Which of the above statements is correct? A. Insertion location and Mergesort are examples of comparison-based sorting algorithms.B. Quicksort is an example of the "divide-and-conquer" algorithm technique.C. Mergesort is a sorting algorithm which in both worst and average case has T (n) = 0 (n log2 n).D. Heapsort has a time complexity in the worst case that is better (faster) than the time complexity of Quicksort in the worst case.E. Selection type has the time complexity T (n) = O (n log2 n) in the worst case.F. Radixsort is not a comparison-based sorting algorithm. Group of answer options All statements are correct. No statement is correct. All statements except D are correct. All statements except E are correct. Only statements A, B, C and D are correct. Only statements A, B and F are correct.
1. (a)The objective is to shuffle a given array of n different elements. You would like to compare various shuffling algorithms and select the best of them. What does it mean: “the best shuffling algorithm”? What is a requirement for the perfect shuffling algorithm? (b) Is the Fisher-Yates Shuffle the perfect shuffling algorithm? Present a formal mathematical proof that this algorithm meets (or does not meet) the requirement given in (a). (c) Evaluate empirically performance of the Fisher-Yates Shuffle for selected numerical values of n. Propose your evaluation criteria and explain your evaluation methodology. Report your observations and conclusions.
Consider the following snippets of code. Then, identify and describe the sorting algorithm used. num scores[5] = 90,85,65,95,75 sort() x = 1 while x < SIZE temp = scores[x] y = x – 1 while y >= 0 AND scores[y]>temp scores[y+1] = scores[y] y = y – 1 endwhile scores[y+1] = temp x = x + 1 endwhile return
Given a set of jobs {J1, ... , Jn}, each job Ji = < ti, wi > has a required processing time ti and aweight wi. Design an efficient algorithm (pseudo code) to minimize the weighted sum of overall completion times ∑ni=1wiCi, where Ci is the completion time of job i. What is the time complexityof your algorithm? Note: You first need to briefly explain your ideas to solve the problem, e.g. what data structures are used, how the intermediate results are saved, which sorting strategy is used, and why the final results are correct;
Convert the algorithm below into a pseudocode with the complexity of O (lg n)! (PS: use divide and conquer algorithm) _________________________________________________________________________ #include <stdio.h> int Search(int Data[], int Left, int Right, int Difference){ int Mid = Left + (Right - Left)/2; if (Data[Mid+1] - Data[Mid] != Difference) return (Data[Mid] + Difference); if (Mid > 0 && Data[Mid] - Data[Mid-1] != Difference) return (Data[Mid-1] + Difference); if (Data[Mid] == Data[0] + Mid*Difference) return Search(Data, Mid+1, Right, Difference); return Search(Data, Left, Mid-1, Difference);} int main(){ int Data[] = {1,13,25,49,61,73,85,97,109,121,133,145,157,169,181}; int n = sizeof(Data)/sizeof(Data[0]); int Difference = (Data[n-1] - Data[0])/n; printf("%d", Search(Data, 0, n-1,Difference)); return 0;}
How to calculate the time complexity in seconds/ minutes for this Insertion Sort algorithm implemented in Python. Time Complexity of this algorithm is O(N2). # Function to do insertion sortdef insertionSort(arr): # Traverse through 1 to len(arr) for i in range(1, len(arr)): key = arr[i] j = i-1 while j >=0 and key < arr[j] : arr[j+1] = arr[j] j -= 1 arr[j+1] = keyarr = [12, 11, 13, 5, 6]insertionSort(arr)lst = [] #empty list to store sorted elementsprint("Sorted array is : ")for i in range(len(arr)): lst.append(arr[i]) print(lst)
Given an array of positive and negative integers, write the main ideas of an algorithm to segregate them without changing the relative order of elements. The output should contain all positive numbers follow negative numbers while maintaining the same relative ordering. Example: Input: [9, -3, 5, -2, -8, -6, 1, 3] Output: [-3, -2, -8, -6, 9, 5, 1, 3] Determine the running time complexity of this algorithm
Please justify your answer: Some sorting algorithms require extra space, apart from the space needed for the original array that needs to be sorted. Which one of the following statements on the space usage of sorting algorithms is correct? a.) A Heapsort for sorting an array of size N requires an amount of extra space proportional to N. b.) Insertion Sort for sorting an array of size N requires an amount of extra space proportional to N. c.) Merge sort for sorting an array of size N requires an amount of extra space proportional to N. d.) Quicksort for sorting an array of size N requires an amount of extra space proportional to N. e.) None of the above
Write an efficient algorithm for the following problem, and describe your reasoning. Determine the Time complexity and if you cannot find any polynomial time algorithm, then give a backtracking algorithm. Problem: Binary Array Core Input: Two integers p and q and a binary array A[1...n], i.e., each entry contains either a 0 or 1. Output: Print Yes - if there exists a subarray A[i...k], where 1<= i < k <= n, with exactly p zeros in A[1...i-1] (there may be 1s) and exactly q ones in A[k+1...n] (there may be 0s). Print No - otherwise. Outputs with examples Input: A = [0,1,1,0,1], p = 2, q =1, Output: No. Input: A = [0, 1,1,0, 0,1,0,1], p = 1, q =1, Output: Yes because we can have A[1...i-1] = [0] and A[k+1 ... n] = [0,1,0,1]
Justify each answer. Write pseudocode for an algorithm that interchanges the values of the variables m and n, using only assignments (assigning values to variables). Arrange the functions (1.5)n, n100, (log2n)3, 10n, n!, and n99 so that each function is big-O of the next function. Give a big-O estimate for the following algorithm: count = array of k + 1 zeros for x in input do count[key(x)] + = 1 end for total = 0 for i in 0,1,...k do count[i], total = total, count[i] + total end for output = array of the same length as input for x in input do output[count[key(x)]] = x count[key(x)] + = 1 end for return output
Consider a hybrid sorting algorithm that combines Mergesort with Insertion Sort.It uses Mergesort until the number of elements in the input becomes smaller than or equal to 8, after which it switches to Insertion Sort. What is the number of key comparisons performed by this hybrid sorting algorithm in the best case when running on an input array of size n? Briefly justify your answer. You could assume n = 2k, k is more than 3
Consider the following algorithm and answer the following questions. procedure Algo1(a1, a2, . . . , an: integers) k := 0 for i := 1 to n if ai is even then k := i return k{k is the desired location(or 0 if there are no evens)} What does the given algorithm compute??? Execute the given algorithm and complete the following table by using the list 3, 5, 8, 10, 5, 2, 1, 7, 3, 13. i ai k 1 3 2 5 3 8 4 10 5 5 6 2 7 1 8 7 9 3 10 13