Part IV In Lecture 6, we sketched the radix sort algorithm for sorting an array of n d-digit integers, with each digit in base k, in linear time (d(n + k)). The basic algorithm is as follows: for j=1..d do sort the input stably by each element's jth least-significant digit The sort we used in each pass through the loop was Counting Sort, but any stable sort will work (albeit perhaps with different overall complexity). We tried this algorithm and saw that it worked on an example. Your job is to prove inductively that this algorithm works in general. The class notes suggest proving the following loop invariant: after j passes through the loop, the input is sorted according to the integers formed by each element's j least-significant digits. 18. State and prove a suitable base case for the proof. 19. Now state and prove an inductive case for the proof. You may assume that the per-digit sort used in each iteration is (1) correct and (2) stable. 20. Why does the invariant imply that the radix sort as a whole is correct?

Part IV In Lecture 6, we sketched the radix sort algorithm for sorting an array of n d-digit integers, with each digit in base k, in linear time (d(n + k)). The basic algorithm is as follows: for j=1..d do sort the input stably by each element's jth least-significant digit The sort we used in each pass through the loop was Counting Sort, but any stable sort will work (albeit perhaps with different overall complexity). We tried this algorithm and saw that it worked on an example. Your job is to prove inductively that this algorithm works in general. The class notes suggest proving the following loop invariant: after j passes through the loop, the input is sorted according to the integers formed by each element's j least-significant digits. 18. State and prove a suitable base case for the proof. 19. Now state and prove an inductive case for the proof. You may assume that the per-digit sort used in each iteration is (1) correct and (2) stable. 20. Why does the invariant imply that the radix sort as a whole is correct?

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

We have an almost ordered array with N elements.Almost sequential expression means that each element in an array isTo the right or to the left, from the position that should be lined up.at most k positions away (a function of k << N and k Nis not). This is how a given sequence is processed faster than linearrhythmic complexity.the algorithm that can rank in the asymptotic complexity categoryWrite it as pseudocode. Asymptotic why you specify your algorithmExplain that it is in the category of complexity. As you write your algorithmMake sure to comply with the signature given below. Algoritma neredeyseSiraliyiSirala(A[0..n-1], k)//Input: n elemanlı neredeyse sıralı bir dizi, ve k değeri.//Output : dizinin küçükten büyüğe sıralamış hali.
a. Show step-by-step application of the Selection sort algorithm for the array given below. What is the time complexity of this algorithm? 20 12 10 15 2 b. Consider the below array and show all steps for carrying out one partition of quick sort algorithm. Consider first element as the pivot element. 54 26 93 17 77 31 44 55 20
1. Consider the algorithm for the sorting problem that sorts an array by counting,for each of its elements, the number of smaller elements and then uses thisinformation to put the element in its appropriate position in the sorted array:ALGORITHMComparisonCountingSort(A[0..n − 1])//Sorts an array by comparison counting//Input: Array A[0..n//Output: Array S[0..n− 1] of orderable values− 1] of A’s elements sorted// in nondecreasing orderfor i ← 0 to nCount− 1 do[i]←0for i ← 0 to n − 2 dofor j ← i +1 to n − 1 doif A[i] < A[j ]Count[j ]← Count[j ] + 1else Count[i]← Count[i] + 1for i ←0 to n−1 doS[Count[i]]←A[i]return Sa. Apply this algorithm to sorting the list 60, 35, 81, 98, 14, 47.b. Is this algorithm stable?c. Is it in-place?
In this problem, consider a non-standard sorting algorithm called the Slow Sort. Given anarray A[1 : n] of n integers, the algorithm is as follows: Slow-Sort(A[1 : n]):1. If n < 100, run merge sort (or selection sort or insertion sort) on A.2. Otherwise, run Slow-Sort(A[1 : n −1]), Slow-Sort(A[2 : n]), and Slow-Sort(A[1 : n −1]) again. Question: Prove the correctness of Slow-Sort.
develop an implementation TwoSumFaster thatuses a linear algorithm to count the pairs that sum to zero after the array is sorted (instead of the binary-search-based linearithmic algorithm). Then apply a similar idea todevelop a quadratic algorithm for the 3-sum problem.
The recursive algorithm below takes as input an array A of distinct integers, indexed between s andf, and an integer k. The algorithm returns the index of the integer k in the array A, or ?1 if the integerk is not contained within A. Complete the missing portion of the algorithm in such a way that you makethree recursive calls to subarrays of approximately one third the size of A.• Write and justify a recurrence for the runtime T(n) of the above algorithm.• Use the recursion tree to show that the algorithm runs in time O(n).FindK(A,s,f,k)if s < fif f = s + 1if k = A[s] return sif k = A[f] return felseq1 = b(2s + f)=3cq2 = b(q1 + 1 + f)=2c... to be continued.else... to be continued.
in C++ Given an array A and a positive integer k, the selection problem amounts to finding the largest element x ∈ A such that at most k elements of A are less than or equal to x, or nil if no such element exists. A simple way to implement it is as follows: SimpleSelection(A, k) 1 if k > A.length 2 return nil 3 else sort A in ascending order 4 return A[k] Write another algorithm that solves the selection problem by sorting (using selection and bubble sort) A. Also, illustrate the execution of the algorithm on the following input by writing its state at each main iteration. A = (29, 28, 35, 20, 9, 33, 8, 9, 11, 6, 21, 28, 18, 36, 1) k = 6
Question1 (b)Consider the followingalgorithmwhere Small is an array of ninteger values: AlgorithmQ1 //Input: An array Smallcontaining ninteger values b = ∞ for h = 1 to n-1 for k = h + 1 to n if (Small[h] –Small[k]) < b b = Small[h] –Small[k] return b i.Explain what does this algorithm compute. ii.Findthe asymptotic bound/complexity ofthis algorithm. iii.Producean improved algorithm to Question1 (b) above with a better asymptotic complexity/running time. iv.Findthe asymptotic bound/complexity of the improvedalgorithmin Question 1(b)iii. above.
Consider a Binary Search Algorithm that performs a search for the number 48 within the following unsorted list. Using paper and pencil, show the detailed steps for that search algorithm until 48 is found. You must use bubble sort if need it.1019134353415604870
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
1. a) Given the array of numbers 50 10 90 120 -13 3 89, you are asked to apply BinarySearch to find a certain number. What would be the best achievable time complexity? Give reason b) Let's say we are running QuickSort on an array of size 900. Our algorithm has completed 90 partitions. How many items in the array is now guaranteed to be in their designated spot? c)What can cause worst performance for quick sort algorithm on this array of 900 items?
Consider the following sorting problem: you must reorder the elements of an array of numbersin-place so that odd numbers are in odd positions while even numbers are in even positions. Ifthere are more even elements than odd ones in A (or vice-versa) then those additional elementswill be grouped at the end of the array. For example, with an initial sequenceA = 50, 47, 92, 78, 76, 7, 60, 36, 59, 30, 50, 43The result could be this:A = 47, 50, 7, 92, 59, 78, 59, 76, 43, 92, 36, 60, 30, 50