Suppose we have an O(n) time algorithm that finds the median of an unsorted array. Now consider a QuickSort implementation where we first find median using the above algorithm, then use median as the pivot. What will be the worst-case time complexity of this modified QuickSort? (A) O(n^2 Logn) (B) O(n^2) (C) O(n Logn Logn) (D) O(nLogn) (E) O(n)

Suppose we have an O(n) time algorithm that finds the median of an unsorted array. Now consider a QuickSort implementation where we first find median using the above algorithm, then use median as the pivot. What will be the worst-case time complexity of this modified QuickSort? (A) O(n^2 Logn) (B) O(n^2) (C) O(n Logn Logn) (D) O(nLogn) (E) O(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

Given a matrix of size N x M where N is the number of rows and M is the number of columns, write an algorithm to find the shortest path from the top-left cell to the bottom-right cell that passes through all the cells with a prime value and avoids cells with composite values. The algorithm should have a time complexity of O(NM log(max(N,M))).
Given a sorted array of n comparable items A, and a search value key, return the position (array index) of key in A if it is present, or -1 if it is not present. If key is present in A, your algorithm must run in order O(log k) time, where k is the location of key in A. Otherwise, if key is not present, your algorithm must run in O(log n) time.
Suppose you have m sorted arrays, each with n elements, and you want to combine them into a single sorted array with mn elements. 1. If you do this by merging the first two arrays, next with the third, then with the fourth, until in the end with the last one. What is the time complexity of this algorithm, in terms of m and n? 2. Give a more efficient solution to this problem, using divide-and-conquer. What is the running time?
Write an algorithm called MatrixRowMultiple(A[0…n – 1, 0… n – 1]) which takes an n x n matrix A and outputs if true, if each element in the first row is twice the value of the corresponding element of row 2. Otherwise, it returns false. (ii) Determine the worst case complexity of the algorithm which you have developed.
Given two sorted arrays nums1 and nums2 of size m and n respectively, return the median of the two sorted arrays. The overall run time complexity should be O(log (m+n)). Example 1: Input: nums1 = [1,3], nums2 = [2] Output: 2.00000 Explanation: merged array = [1,2,3] and median is 2. Example 2: Input: nums1 = [1,2], nums2 = [3,4] Output: 2.50000 Explanation: merged array = [1,2,3,4] and median is (2 + 3) / 2 = 2.5. Constraints: nums1.length == m nums2.length == n 0 <= m <= 1000 0 <= n <= 1000 1 <= m + n <= 2000 -106 <= nums1[i], nums2[i] <= 106
Given two sorted arrays A and B, design a linear (O(IA|+|B|)) time algorithm for computing the set C containing elements that are in A or B, but not in both. That is, C = (AU B) \ (AN B). You can assume that elements in A have different values and elements in B also have different values. Please state the steps of your algorithm clearly, prove that it is correct, and analyze its running time. Pls give the code in C++, or very clear steps of the algorithm
You are given an unsorted array A[1, ..., n].We know that the maximum (or minimum) element in the array can be found in (n-1) comparisons.Write an algorithm that finds both the maximum and the minimum element in the array in ~(3n/2) comparisons, i.e., (3n/2) + THETA(1) comparisons.
Given two sorted arrays nums1 and nums2 of size m and n respectively, return the median of the two sorted arrays. The overall run time complexity should be o(log (m+n)). Example 1: Input: nums1 [1,3], nums2 = [2] Output: 2.00000 Explanation: merged array = [1,2,3] and median is 2. Example 2: Input: nums1 [1,2], nums2 = [3,4] Output: 2.50000 Explanation: merged array = [1,2,3,4] and median is (2 + 3) / 2 = 2.5. Constraints: nums1.length == m • nums2.length == n 0 <= m <= 1000 0 <= n <= 1000 1 <= m + n <= 2000 -10° <= nums1[i], nums2[i] <= 10°
Given two sorted arrays nums1 and nums2 of size m and n respectively, return the median of the two sorted arrays. The overall run time complexity should be O(log (m+n)). Example 1: Input: nums1 = [1,3], nums2 = [2] Output: 2.00000 Explanation: merged array = [1,2,3] and median is 2. Example 2: Input: nums1 = [1,2], nums2 = [3,4] Output: 2.50000 Explanation: merged array = [1,2,3,4] and median is (2 + 3) / 2 = 2.5. Constraints: nums1.length == m nums2.length == n 0 <= m <= 1000 0 <= n <= 1000 1 <= m + n <= 2000 -106 <= nums1[i], nums2[i] <= 106 Write the whole code in python language Attach the code outputs also and explain the implementation.
Given an unsorted array of integers, find the length oflongest increasing subsequence.Example:Input: [10,9,2,5,3,7,101,18]Output: 4Explanation: The longest increasing subsequence is [2,3,7,101], therefore thelength is 4.Time complexity:First algorithm is O(n^2).Second algorithm is O(nlogx) where x is the max element in the listThird algorithm is O(nlogn)Space complexity:First algorithm is O(n)Second algorithm is O(x) where x is the max element in the listThird algorithm is O(n)""" def longest_increasing_subsequence(sequence): """ Dynamic Programming Algorithm for counting the length of longest increasing subsequence type sequence: list[int] rtype: int """ length = len(sequence) counts = [1 for _ in range(length)] for i in range(1, length): for j in range(0, i): if sequence[i] > sequence[j]: counts[i] = max(counts[i], counts[j] + 1) print(counts) return max(counts) def…
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]
Consider an n by n matrix, where each of the n2 entries is a positive integer. If the entries in this matrix are unsorted, then determining whether a target number t appears in the matrix can only be done by searching through each of the n2 entries. Thus, any search algorithm has a running time of O(n²). However, suppose you know that this n by n matrix satisfies the following properties: • Integers in each row increase from left to right. • Integers in each column increase from top to bottom. An example of such a matrix is presented below, for n=5. 4 7 11 15 2 5 8 12 19 3 6 9 16 22 10 13 14 17 24 1 18 21 23 | 26 | 30 Here is a bold claim: if the n by n matrix satisfies these two properties, then there exists an O(n) algorithm to determine whether a target number t appears in this matrix. Determine whether this statement is TRUE or FALSE. If the statement is TRUE, describe your algorithm and explain why your algorithm runs in O(n) time. If the statement is FALSE, clearly explain why no…