DOCSLIB.ORG

CS 361, Lecture 14 Outline Bucket Sort Bucket Sort

Total Page：16

File Type：pdf, Size：1020Kb

Download full-text PDF Read full-text
CS 361, Lecture 14 Outline Bucket Sort Bucket Sort Bucket Sort Bucket sort assumes that the input is drawn from a uniform ² CS 361, Lecture 14 distribution over the range [0; 1) Basic idea is to divide the interval [0; 1) into n equal size ² Jared Saia regions, or buckets University of New Mexico We expect that a small number of elements in A will fall into ² each bucket To get the output, we can sort the numbers in each bucket ² and just output the sorted buckets in order 2 Outline Bucket Sort //PRE: A is the array to be sorted, all elements in A[i] are between $0$ and $1$ inclusive. //POST: returns a list which is the elements of A in sorted order BucketSort(A){ B = new List[] Bucket Sort n = length(A) ² Midterm Review for (i=1;i<=n;i++){ ² insert A[i] at end of list B[floor(n*A[i])]; } for (i=0;i<=n-1;i++){ sort list B[i] with insertion sort; } return the concatenated list B[0],B[1],...,B[n-1]; } 1 3 Bucket Sort Analysis We claim that E(n2) = 2 1=n Claim: If the input numbers are distributed uniformly over ² i ¡ ² To prove this, we de¯ne indicator random variables: X = 1 the range [0; 1), then Bucket sort takes expected time O(n) ² ij if A[j] falls in bucket i and 0 otherwise (de¯ned for all i, Let T (n) be the run time of bucket sort on a list of size n ² 0 i n 1 and j, 1 j n) Let ni be the random variable givingthe number of elements · · ¡ · · ² Thus, n = n X in bucket [ ] i j=1 ij B i ² 2 n 1 2 We can nowP compute E(ni ) by expanding the square and Then T (n) = £(n) + ¡ O(n ) ² ² i=0 i regrouping terms P 4 6 Analysis Analysis n 1 2 We know T (n) = £(n) + ¡ O(n ) ² i=0 i Taking expectation of both sides, we have ² P n 1 n ¡ 2 E(n ) = E(( X )2) E(T (n)) = E(£(n) + O(ni )) i2 ij j=1 iX=0 X n 1 n n ¡ 2 = E( X X ) = £(n) + E(O(ni )) ij ik j=1 k=1 iX=0 X X n 1 n ¡ 2 = E( X2 + X X ) = £(n) + (O(E(ni ))) ij ij ik i=0 jX=1 1 Xj n 1 k Xn;k=j X n · · · · 6 2 The second step follows by linearity of expectation = E(Xij) + E(XijXik)) ² j=1 1 j n 1 k n;k=j The last step holds since for any constant a and random X ·X· · ·X 6 ² variable X, E(aX) = aE(X) (see Equation C.21 in the text) 5 7 Analysis Analysis We can evaluate the two summations separately. Xij is 1 ² n 1 2 with probability 1 and 0 otherwise Recall that E(T (n)) = £(n) + ¡ (O(E(n ))) =n ² i=0 i 2 2 Thus E(X ) = 1 (1=n) + 0 (1 1=n) = 1=n We can now plug in the equationP E(ni ) = 2 (1=n) to get ² ij ¤ ¤ ¡ ² ¡ Where k = j, the random variables Xij and Xik are indepen- n 1 ² 6 ¡ dent E(T (n)) = £(n) + 2 (1=n) ¡ For any two independent random variables X and Y , E(XY ) = iX=0 ² = £(n) + £(n) E(X)E(Y ) (see C.3 in the book for a proof of this) = £( ) Thus we have that n ² E(X X ) = E(X )E(X ) ij ik ij ik Thus the entire bucket sort algorithm runs in expected linear = (1=n)(1=n) ² time = (1=n2) 8 10 Analysis Midterm Substituting these two expected values back into our main ² equation, we get: Midterm: Tuesday, March 23rd in class (the Tuesday after ² n spring break) 2 2 E(ni ) = E(Xij) + E(XijXik)) You can bring 2 pages of \cheat sheets" to use during the jX=1 1 Xj n 1 k Xn;k=j ² n · · · · 6 exam. Otherwise the exam is closed book and closed note = (1=n) + (1=n2) Note that the web page contains links to prior classes and ² j=1 1 j n 1 k n;k=j X ·X· · ·X 6 their midterms. Many of the questions on my midterm will 2 = n(1=n) + (n)(n 1)(1=n ) be similar in avor to these past midterms (and to exercises ¡ = 1 + (n 1)=n in the book)! ¡ = 2 (1=n) ¡ 9 11 Review Session Question 1 Collection of true/false questions and short answer on: Asymptotic notation: e.g. I give you a bunch of functions ² and ask you to give me the simplest possible theta notation for each I will have a review session on Monday, March 22nd from ² Recurrences: e.g. I ask you to solve a recurrence 5:30-6:30 in FEC 141 (conference room on ¯rst oor of ² Heaps: e.g. I ask you questions about properties of heaps FEC) ² and priority queues Please try to make it to this review session if at all possible ² Sorting Algorithms: heapsort, quicksort, bucketsort, merge- ² sort, (know resource bounds for these algorithms) Probability: Random variables, expectation, linearity of ex- ² pectation, birthday paradox, analysis of expected runtime of quicksort and bucketsort 12 14 Midterm Question 2 Solving recurrence relations: 5 questions, about 20 points each ² Like problems on hw 4 and Problem 7-3 (Stooge Sort) Hard but fair ² ² You'll need to know annihilators, change of variables, han- There will be some time pressure, so make sure you can e.g. ² ² dling homogeneous and non-homogeneous parts of recur- solve recurrences both quickly and correctly. rences, recursion trees, and the Master Method I expect a class mean of between 60 :( and 70 :) points ² You'll need to know the formulas for sums of convergent and ² divergent geometric series 13 15 Question 3 Questions 5 Loop Invariant: Will give you an algorithm and ask you to give the loop Asymptotic notation: ² invariant you would use to show it is correct You may also need to give initialization, maintenance and Similar to book problems: 3.1-2, 3.1-5, 3.1-7 ² ² termination for your loop invariant Similar to the hw problems and in-class exercises on loop ² invariants 16 18 Question 4 Asymptotic Notation Let's now review asymptotic notation ² I'll review for O notation, make sure you understand the other Recurrence proof using induction (i.e. the substitution method): ² four types f(n) = O(g(n)) if there exists positive constants c and n0 You'll need to give base case, inductive hypothesis and then ² ² such that 0 f(n) cg(n) for all n n0 show the inductive step · · ¸ This means to show that f(n) = O(g(n)), you need to give Similar to Exercises 7.2-1, 4.2-1 and 4.2-3 ² ² positive constants c and n0 for which the above statement is true! 17 19 Example 1 Example 3 Prove that 22n = O(5n) Prove that 2n+1 = O(2n) ² ² Goal: Show there exist positive constants c and n0 such that Goal: Show there exist positive constants c and n0 such that ² 2n n ² 2 c 5 for all n n0 2n+1 c 2n for all n n · ¤ ¸ · ¤ ¸ 0 22n c 5n (7) 2n+1 c 2n (1) · ¤ · ¤ 4n c 5n (8) 2 2n c 2n (2) · ¤ ¤ · ¤ (4=5)n c (9) 2 c (3) · · (10) n+1 n Hence for c = 2 and n0 = 1, 2 c 2 for all n n0 ² · ¤ ¸ Hence for c = 1 and n = 1, 22n c 5n for all n n ² 0 · ¤ ¸ 0 20 22 Example 2 A Procedure Prove that n + pn = O(n) ² Goal: Show there exist positive constants c and n such that Goal: prove that f(n) = O(g(n)) ² 0 n + pn c n for all n n · ¤ ¸ 0 1. Write down what this means mathematically n + pn c n (4) · ¤ 2. Write down the inequality f(n) c g(n) 1 · ¤ 1 + c (5) 3. Simplify this inequality so that c is isolated on the right hand pn · (6) side 4. Now ¯nd a n0 and a c such that for all n n0, this simpli¯ed Hence if we choose n = 4, and c = 1:5, then it's true that ¸ ² 0 inequality is true n + pn c n for all n n · ¤ ¸ 0 21 23 In Class Exercise Example: Substitution Method Base Case: T (1) = 2 which is in fact 21. ² Show that n2n is O(4n) Inductive Hypothesis: For all j < n, T (j) = 2j ² Inductive Step: We must show that T (n) = 2n, assuming the ² Q1: What is the exact mathematical statement of what you inductive hypothesis. ² need to prove? 2 n T (n) = 2 ¡ T (n 1) T (n 1) Q2: What is the ¯rst inequality in the chain of inequalities? 2 n ¤ n 1¡ n¤ 1 ¡ ² T (n) = 2 ¡ 2 ¡ 2 ¡ Q3: What is the simpli¯ed inequality where c is isolated? ¤ ¤ ² T (n) = 2n Q4: What is a n and c such that the inequality of the last ² 0 question is always true? where the inductive hypothesis allows us to make the replace- ments in the second step. 24 26 Example: Substitution Method Todo Consider the following recurrence: ² T (n) = 22 n T (n 1) T (n 1) ¡ ¤ ¡ ¤ ¡ Enjoy Spring! where T (1) = 2. ² Study for Midterm Show that T (n) = 2n by induction. Include the following ² ² in your proof: 1)the base case(s) 2)the inductive hypothesis and 3)the inductive step.
Load more

Recommended publications
  • Sorting Algorithms Correcness, Complexity and Other Properties
    Sorting Algorithms Correcness, Complexity and other Properties Joshua Knowles School of Computer Science The University of Manchester COMP26912 - Week 9 LF17, April 1 2011 The Importance of Sorting Important because • Fundamental to organizing data • Principles of good algorithm design (correctness and efficiency) can be appreciated in the methods developed for this simple (to state) task. Sorting Algorithms 2 LF17, April 1 2011 Every algorithms book has a large section on Sorting... Sorting Algorithms 3 LF17, April 1 2011 ...On the Other Hand • Progress in computer speed and memory has reduced the practical importance of (further developments in) sorting • quicksort() is often an adequate answer in many applications However, you still need to know your way (a little) around the the key sorting algorithms Sorting Algorithms 4 LF17, April 1 2011 Overview What you should learn about sorting (what is examinable) • Definition of sorting. Correctness of sorting algorithms • How the following work: Bubble sort, Insertion sort, Selection sort, Quicksort, Merge sort, Heap sort, Bucket sort, Radix sort • Main properties of those algorithms • How to reason about complexity — worst case and special cases Covered in: the course book; labs; this lecture; wikipedia; wider reading Sorting Algorithms 5 LF17, April 1 2011 Relevant Pages of the Course Book Selection sort: 97 (very short description only) Insertion sort: 98 (very short) Merge sort: 219–224 (pages on multi-way merge not needed) Heap sort: 100–106 and 107–111 Quicksort: 234–238 Bucket sort: 241–242 Radix sort: 242–243 Lower bound on sorting 239–240 Practical issues, 244 Some of the exercise on pp.
    [Show full text]
  • An Evolutionary Approach for Sorting Algorithms
    ORIENTAL JOURNAL OF ISSN: 0974-6471 COMPUTER SCIENCE & TECHNOLOGY December 2014, An International Open Free Access, Peer Reviewed Research Journal Vol. 7, No. (3): Published By: Oriental Scientific Publishing Co., India. Pgs. 369-376 www.computerscijournal.org Root to Fruit (2): An Evolutionary Approach for Sorting Algorithms PRAMOD KADAM AND Sachin KADAM BVDU, IMED, Pune, India. (Received: November 10, 2014; Accepted: December 20, 2014) ABstract This paper continues the earlier thought of evolutionary study of sorting problem and sorting algorithms (Root to Fruit (1): An Evolutionary Study of Sorting Problem) [1]and concluded with the chronological list of early pioneers of sorting problem or algorithms. Latter in the study graphical method has been used to present an evolution of sorting problem and sorting algorithm on the time line. Key words: Evolutionary study of sorting, History of sorting Early Sorting algorithms, list of inventors for sorting. IntroDUCTION name and their contribution may skipped from the study. Therefore readers have all the rights to In spite of plentiful literature and research extent this study with the valid proofs. Ultimately in sorting algorithmic domain there is mess our objective behind this research is very much found in documentation as far as credential clear, that to provide strength to the evolutionary concern2. Perhaps this problem found due to lack study of sorting algorithms and shift towards a good of coordination and unavailability of common knowledge base to preserve work of our forebear platform or knowledge base in the same domain. for upcoming generation. Otherwise coming Evolutionary study of sorting algorithm or sorting generation could receive hardly information about problem is foundation of futuristic knowledge sorting problems and syllabi may restrict with some base for sorting problem domain1.
    [Show full text]
  • CS 106B Lecture 11: Sorting Friday, October 21, 2016
    CS 106B Lecture 11: Sorting Friday, October 21, 2016 Programming Abstractions Fall 2016 Stanford University Computer Science Department Lecturer: Chris Gregg reading: Programming Abstractions in C++, Section 10.2 Today's Topics •Logistics •We will have a midterm review, TBA •Midterm materials (old exams, study guides, etc.) will come out next week. •Throwing a string error •Recursive != exponential computational complexity •Sorting •Insertion Sort •Selection Sort •Merge Sort •Quicksort •Other sorts you might want to look at: •Radix Sort •Shell Sort •Tim Sort •Heap Sort (we will cover heaps later in the course) •Bogosort Throwing an Exception • For the Serpinski Triangle option in MetaAcademy assignment says, "If the order passed is negative, your function should throw a string exception." • What does it mean to "throw a string exception?" • An "exception" is your program's way of pulling the fire alarm — something drastic happened, and your program does not like it. In fact, if an exception is not "handled" by the rest of your program, it crashes! It is not a particularly graceful way to handle bad input from the user. • If you were going to use your Serpinski function in a program you wrote, you would want to check the input before calling the function — in other words, make sure your program never creates a situation where a function needs to throw an exception. Throwing an Exception • To throw an exception: throw("Illegal level: Serpinski level must be non-negative."); • This will crash the program. • You can "catch" exceptions that have been thrown by other functions, but that is beyond our scope — see here for details: https://www.tutorialspoint.com/ cplusplus/cpp_exceptions_handling.htm (that is a creepy hand) Recursion != Exponential Computational Complexity • In the previous lecture, we discussed the recursive fibonacci function: long fibonacci(int n) { • This function happens to have if (n == 0) { return 0; exponential computational complexity } if (n == 1) { because each recursive call has two return 1; } additional recursions.
    [Show full text]
  • Parallel Sorting Algorithms + Topic Overview
    + Design of Parallel Algorithms Parallel Sorting Algorithms + Topic Overview n Issues in Sorting on Parallel Computers n Sorting Networks n Bubble Sort and its Variants n Quicksort n Bucket and Sample Sort n Other Sorting Algorithms + Sorting: Overview n One of the most commonly used and well-studied kernels. n Sorting can be comparison-based or noncomparison-based. n The fundamental operation of comparison-based sorting is compare-exchange. n The lower bound on any comparison-based sort of n numbers is Θ(nlog n) . n We focus here on comparison-based sorting algorithms. + Sorting: Basics What is a parallel sorted sequence? Where are the input and output lists stored? n We assume that the input and output lists are distributed. n The sorted list is partitioned with the property that each partitioned list is sorted and each element in processor Pi's list is less than that in Pj's list if i < j. + Sorting: Parallel Compare Exchange Operation A parallel compare-exchange operation. Processes Pi and Pj send their elements to each other. Process Pi keeps min{ai,aj}, and Pj keeps max{ai, aj}. + Sorting: Basics What is the parallel counterpart to a sequential comparator? n If each processor has one element, the compare exchange operation stores the smaller element at the processor with smaller id. This can be done in ts + tw time. n If we have more than one element per processor, we call this operation a compare split. Assume each of two processors have n/p elements. n After the compare-split operation, the smaller n/p elements are at processor Pi and the larger n/p elements at Pj, where i < j.
    [Show full text]
  • Investigating the Effect of Implementation Languages and Large Problem Sizes on the Tractability and Efficiency of Sorting Algorithms
    International Journal of Engineering Research and Technology. ISSN 0974-3154, Volume 12, Number 2 (2019), pp. 196-203 © International Research Publication House. http://www.irphouse.com Investigating the Effect of Implementation Languages and Large Problem Sizes on the Tractability and Efficiency of Sorting Algorithms Temitayo Matthew Fagbola and Surendra Colin Thakur Department of Information Technology, Durban University of Technology, Durban 4000, South Africa. ORCID: 0000-0001-6631-1002 (Temitayo Fagbola) Abstract [1],[2]. Theoretically, effective sorting of data allows for an efficient and simple searching process to take place. This is Sorting is a data structure operation involving a re-arrangement particularly important as most merge and search algorithms of an unordered set of elements with witnessed real life strictly depend on the correctness and efficiency of sorting applications for load balancing and energy conservation in algorithms [4]. It is important to note that, the rearrangement distributed, grid and cloud computing environments. However, procedure of each sorting algorithm differs and directly impacts the rearrangement procedure often used by sorting algorithms on the execution time and complexity of such algorithm for differs and significantly impacts on their computational varying problem sizes and type emanating from real-world efficiencies and tractability for varying problem sizes. situations [5]. For instance, the operational sorting procedures Currently, which combination of sorting algorithm and of Merge Sort, Quick Sort and Heap Sort follow a divide-and- implementation language is highly tractable and efficient for conquer approach characterized by key comparison, recursion solving large sized-problems remains an open challenge. In this and binary heap’ key reordering requirements, respectively [9].
    [Show full text]
  • Sorting in Linear Time
    Data Structures Sorting in Linear Time 1 Sorting • Internal (external) – All data are held in primary memory during the sorting process. • Comparison Based – Based on pairwise comparisons. – Lower bound on running time is Ω(nlogn). • In Place – Requires very little, O(log n), additional space. • Stable – Preserves the relative ordering of items with equal values. 2 Lower Bounds for Comparison Sorts • Ω(n) to examine all the input. • All sorts seen so far are Ω(n lg n). • We’ll show that Ω(n lg n) is a lower bound for comparison sorts. 3 Lower Bounds for Comparison Sorts • All possible flows of any comparison sort can be modeled by a decision tree. • For example, the decision tree of insertion sort of 3 elements looks like: • There are at least n! leaves, because every permutation appears at least once. 4 Lower Bounds for Comparison Sorts • Theorem: – Any decision tree that sorts n elements has height Ω(n lg n). • Proof: – The number of leaves l ≥ n! – Any binary tree of height h has ≤ 2h leaves. – Hence, n! ≤ l ≤ 2h – Take logs: h ≥ lg(n!) – Use Stirling’s approximation: n! > (n/e)n – We get: 5 Lower Bounds for Comparison Sorts • Lemma: – Any binary tree of height h has ≤ 2h leaves. • Proof: – By induction on h. – Basis: • h = 0. • Tree is just one node, which is a leaf. • 2h = 1. – Inductive step: • Assume true for height = h − 1. • Reduce all leaves and get a tree of height h – 1 • Make the tree full • Then, extend the tree of height h − 1 by adding to each leaf two son leaves.
    [Show full text]
  • Lecture 8.Key
    CSC 391/691: GPU Programming Fall 2015 Parallel Sorting Algorithms Copyright © 2015 Samuel S. Cho Sorting Algorithms Review 2 • Bubble Sort: O(n ) 2 • Insertion Sort: O(n ) • Quick Sort: O(n log n) • Heap Sort: O(n log n) • Merge Sort: O(n log n) • The best we can expect from a sequential sorting algorithm using p processors (if distributed evenly among the n elements to be sorted) is O(n log n) / p ~ O(log n). Compare and Exchange Sorting Algorithms • Form the basis of several, if not most, classical sequential sorting algorithms. • Two numbers, say A and B, are compared between P0 and P1. P0 P1 A B MIN MAX Bubble Sort • Generic example of a “bad” sorting 0 1 2 3 4 5 algorithm. start: 1 3 8 0 6 5 0 1 2 3 4 5 Algorithm: • after pass 1: 1 3 0 6 5 8 • Compare neighboring elements. • Swap if neighbor is out of order. 0 1 2 3 4 5 • Two nested loops. after pass 2: 1 0 3 5 6 8 • Stop when a whole pass 0 1 2 3 4 5 completes without any swaps. after pass 3: 0 1 3 5 6 8 0 1 2 3 4 5 • Performance: 2 after pass 4: 0 1 3 5 6 8 Worst: O(n ) • 2 • Average: O(n ) fin. • Best: O(n) "The bubble sort seems to have nothing to recommend it, except a catchy name and the fact that it leads to some interesting theoretical problems." - Donald Knuth, The Art of Computer Programming Odd-Even Transposition Sort (also Brick Sort) • Simple sorting algorithm that was introduced in 1972 by Nico Habermann who originally developed it for parallel architectures (“Parallel Neighbor-Sort”).
    [Show full text]
  • Sorting Algorithm 1 Sorting Algorithm
    Sorting algorithm 1 Sorting algorithm In computer science, a sorting algorithm is an algorithm that puts elements of a list in a certain order. The most-used orders are numerical order and lexicographical order. Efficient sorting is important for optimizing the use of other algorithms (such as search and merge algorithms) that require sorted lists to work correctly; it is also often useful for canonicalizing data and for producing human-readable output. More formally, the output must satisfy two conditions: 1. The output is in nondecreasing order (each element is no smaller than the previous element according to the desired total order); 2. The output is a permutation, or reordering, of the input. Since the dawn of computing, the sorting problem has attracted a great deal of research, perhaps due to the complexity of solving it efficiently despite its simple, familiar statement. For example, bubble sort was analyzed as early as 1956.[1] Although many consider it a solved problem, useful new sorting algorithms are still being invented (for example, library sort was first published in 2004). Sorting algorithms are prevalent in introductory computer science classes, where the abundance of algorithms for the problem provides a gentle introduction to a variety of core algorithm concepts, such as big O notation, divide and conquer algorithms, data structures, randomized algorithms, best, worst and average case analysis, time-space tradeoffs, and lower bounds. Classification Sorting algorithms used in computer science are often classified by: • Computational complexity (worst, average and best behaviour) of element comparisons in terms of the size of the list . For typical sorting algorithms good behavior is and bad behavior is .
    [Show full text]
  • An Ordering Experiment A
    Journal of Economic Behavior & Organization Vol. 50 (2003) 249–262 An ordering experiment A. Norman∗, M. Ahmed, J. Chou, K. Fortson, C. Kurz, H. Lee, L. Linden, K. Meythaler, R. Rando, K. Sheppard, N. Tantzen, I. White, M. Ziegler Department of Economics, The University of Texas at Austin, Austin, TX 78712-1173, USA Received 12 December 2000; accepted 20 April 2001 Abstract Binary comparison operators form the basis of consumer set theory. If humans could only per- form binary comparisons, the most efficient procedure a human might employ to make a complete n n n preference ordering of items would be a log2 algorithm. But, if humans are capable of assigning each item an ordinal utility value, they are capable of implementing a more efficient linear algo- rithm. In this paper, we consider six incentive systems for ordering three different sets of objects: pens, notebooks, and Hot Wheels. All experimental evidence indicates that humans are capable of implementing a linear algorithm, for small sets. © 2003 Elsevier Science B.V. All rights reserved. JEL classification: C9 Design of Experiments; C91 Laboratory, Individual Behavior; D11 Consumer Economics: Theory; C61 Optimization Techniques; Programming Models; C63 Computational Techniques; C69 Other-Complexity Theory Keywords: Linear algorithm; Binary comparison; Ordering 1. Introduction We experimentally examine the algorithms that individuals use to order sets of objects. Our focus is not the static properties of the ordered objects, but rather the properties of the algorithms that humans use to make the ordering. By comparing human algorithms with known computer ordering algorithms, we can determine their properties. We use complex- ity theory to measure cost and to formulate hypotheses to test among alternative human algorithms.
    [Show full text]
  • Practice Quiz 1 Solutions
    Introduction to Algorithms October 2, 2001 Massachusetts Institute of Technology 6.046J/18.410J Singapore-MIT Alliance SMA5503 Professors Professors Erik Demaine, Lee Wee Sun, and Charles E. Leiserson Handout 16 Practice Quiz 1 Solutions Do not open this quiz booklet until you are directed to do so. This quiz starts at 2:35 P.M. and ends at 3:55 P.M. It contains 3 problems, some with multiple parts. The quiz contains 13 pages, including this one. You have 80 minutes to earn 100 points. ¡£¢ ¤¦¥ ¥¨§ © © ¥ This quiz is closed book. You may use one handwritten ¥ crib sheet. No calculators are permitted. When the quiz begins, write your name on every page of this quiz booklet in the space provided. Write your solutions in the space provided. If you need more space, write on the back of the sheet containing the problem. Do not put part of the answer to one problem on the back of the sheet for another problem, since the pages will be separated for grading. Do not spend too much time on any problem. Read them all through first and attack them in the order that allows you to make the most progress. Show your work, as partial credit will be given. You will be graded not only on the correct- ness of your answer, but also on the clarity with which you express it. Be neat. Good luck! Handout 16: Practice Quiz 1 Solutions 2 Problem 1. Integer Multiplication [15 points] The following algorithm multiplies two nonnegative integers and : MULT 1 2 while © 3 do if ¨ "! %$& 4 then # '( *) !,+ 5 !.
    [Show full text]
  • How to Sort out Your Life in O(N) Time
    How to sort out your life in O(n) time arel Číže @kaja47K funkcionaklne.cz I said, "Kiss me, you're beautiful - These are truly the last days" Godspeed You! Black Emperor, The Dead Flag Blues Everyone, deep in their hearts, is waiting for the end of the world to come. Haruki Murakami, 1Q84 ... Free lunch 1965 – 2022 Cramming More Components onto Integrated Circuits http://www.cs.utexas.edu/~fussell/courses/cs352h/papers/moore.pdf He pays his staff in junk. William S. Burroughs, Naked Lunch Sorting? quicksort and chill HS 1964 QS 1959 MS 1945 RS 1887 quicksort, mergesort, heapsort, radix sort, multi- way merge sort, samplesort, insertion sort, selection sort, library sort, counting sort, bucketsort, bitonic merge sort, Batcher odd-even sort, odd–even transposition sort, radix quick sort, radix merge sort*, burst sort binary search tree, B-tree, R-tree, VP tree, trie, log-structured merge tree, skip list, YOLO tree* vs. hashing Robin Hood hashing https://cs.uwaterloo.ca/research/tr/1986/CS-86-14.pdf xs.sorted.take(k) (take (sort xs) k) qsort(lotOfIntegers) It may be the wrong decision, but fuck it, it's mine. (Mark Z. Danielewski, House of Leaves) I tell you, my man, this is the American Dream in action! We’d be fools not to ride this strange torpedo all the way out to the end. (HST, FALILV) Linear time sorting? I owe the discovery of Uqbar to the conjunction of a mirror and an Encyclopedia. (Jorge Luis Borges, Tlön, Uqbar, Orbis Tertius) Sorting out graph processing https://github.com/frankmcsherry/blog/blob/master/posts/2015-08-15.md Radix Sort Revisited http://www.codercorner.com/RadixSortRevisited.htm Sketchy radix sort https://github.com/kaja47/sketches (thinking|drinking|WTF)* I know they accuse me of arrogance, and perhaps misanthropy, and perhaps of madness.
    [Show full text]
  • Evaluation of Sorting Algorithms, Mathematical and Empirical Analysis of Sorting Algorithms
    International Journal of Scientific & Engineering Research Volume 8, Issue 5, May-2017 86 ISSN 2229-5518 Evaluation of Sorting Algorithms, Mathematical and Empirical Analysis of sorting Algorithms Sapram Choudaiah P Chandu Chowdary M Kavitha ABSTRACT:Sorting is an important data structure in many real life applications. A number of sorting algorithms are in existence till date. This paper continues the earlier thought of evolutionary study of sorting problem and sorting algorithms concluded with the chronological list of early pioneers of sorting problem or algorithms. Latter in the study graphical method has been used to present an evolution of sorting problem and sorting algorithm on the time line. An extensive analysis has been done compared with the traditional mathematical methods of ―Bubble Sort, Selection Sort, Insertion Sort, Merge Sort, Quick Sort. Observations have been obtained on comparing with the existing approaches of All Sorts. An “Empirical Analysis” consists of rigorous complexity analysis by various sorting algorithms, in which comparison and real swapping of all the variables are calculatedAll algorithms were tested on random data of various ranges from small to large. It is an attempt to compare the performance of various sorting algorithm, with the aim of comparing their speed when sorting an integer inputs.The empirical data obtained by using the program reveals that Quick sort algorithm is fastest and Bubble sort is slowest. Keywords: Bubble Sort, Insertion sort, Quick Sort, Merge Sort, Selection Sort, Heap Sort,CPU Time. Introduction In spite of plentiful literature and research in more dimension to student for thinking4. Whereas, sorting algorithmic domain there is mess found in this thinking become a mark of respect to all our documentation as far as credential concern2.
    [Show full text]