Data Structures in Java with JUnit ©Rick Mercer

Slides:



Advertisements
Similar presentations
Stephen P. Carl - CS 2421 Recursive Sorting Algorithms Reading: Chapter 5.
Advertisements

21/3/00SEM107- Kamin & ReddyClass 15 - Recursive Sorting - 1 Class 15 - Recursive sorting methods r Processing arrays by recursion r Divide-and-conquer.
CSE 373: Data Structures and Algorithms
QuickSort The content for these slides was originally created by Gerard Harrison. Ported to C# by Mike Panitz.
Sorting Algorithms and Average Case Time Complexity
Sorting Chapter Sorting Consider list x 1, x 2, x 3, … x n We seek to arrange the elements of the list in order –Ascending or descending Some O(n.
CS 162 Intro to Programming II Quick Sort 1. Quicksort Maybe the most commonly used algorithm Quicksort is also a divide and conquer algorithm Advantage.
Data Structures Advanced Sorts Part 2: Quicksort Phil Tayco Slide version 1.0 Mar. 22, 2015.
Recursion. Objectives At the conclusion of this lesson, students should be able to Explain what recursion is Design and write functions that use recursion.
1 Algorithm Efficiency and Sorting (Walls & Mirrors - Remainder of Chapter 9)
Sorting Algorithms Bubble Sort Merge Sort Quick Sort Randomized Quick Sort.
CS2420: Lecture 11 Vladimir Kulyukin Computer Science Department Utah State University.
Sorting (Part II: Divide and Conquer) CSE 373 Data Structures Lecture 14.
(c) , University of Washington
20-1 Computing Fundamentals with C++ Object-Oriented Programming and Design, 2nd Edition Rick Mercer Franklin, Beedle & Associates, 1999 ISBN
Recursive Quicksort Data Structures in Java with JUnit ©Rick Mercer.
Computer Science 101 Fast Searching and Sorting. Improving Efficiency We got a better best case by tweaking the selection sort and the bubble sort We.
Computer Science Searching & Sorting.
Examples of Recursion Data Structures in Java with JUnit ©Rick Mercer.
Examples of Recursion Data Structures in Java with JUnit ©Rick Mercer.
CSC 211 Data Structures Lecture 13
© M. Gross, ETH Zürich, 2014 Informatik I für D-MAVT (FS 2014) Exercise 12 – Data Structures – Trees Sorting Algorithms.
Sorting Chapter Sorting Consider list x 1, x 2, x 3, … x n We seek to arrange the elements of the list in order –Ascending or descending Some O(n.
Divide-and-Conquer The most-well known algorithm design strategy: 1. Divide instance of problem into two or more smaller instances 2.Solve smaller instances.
Using Recursion to Convert Number to Other Number Bases Data Structures in Java with JUnit ©Rick Mercer.
Computer Science 101 Fast Algorithms. What Is Really Fast? n O(log 2 n) O(n) O(n 2 )O(2 n )
1 Searching and Sorting Searching algorithms with simple arrays Sorting algorithms with simple arrays –Selection Sort –Insertion Sort –Bubble Sort –Quick.
Chapter 6 Recursion. Solving simple problems Iteration can be replaced by a recursive function Recursion is the process of a function calling itself.
Chapter 9 Sorting. The efficiency of data handling can often be increased if the data are sorted according to some criteria of order. The first step is.
Data Structures - CSCI 102 Selection Sort Keep the list separated into sorted and unsorted sections Start by finding the minimum & put it at the front.
The Sorting Methods Lecture Notes 10. Sorts Many programs will execute more efficiently if the data they process is sorted before processing begins. –
PREVIOUS SORTING ALGORITHMS  BUBBLE SORT –Time Complexity: O(n 2 ) For each item, make (n –1) comparisons Gives: Comparisons = (n –1) + (n – 2)
Quicksort This is probably the most popular sorting algorithm. It was invented by the English Scientist C.A.R. Hoare It is popular because it works well.
CS 367 Introduction to Data Structures Lecture 11.
329 3/30/98 CSE 143 Searching and Sorting [Sections 12.4, ]
Recursion. Objectives At the conclusion of this lesson, students should be able to Explain what recursion is Design and write functions that use recursion.
CMPT 120 Topic: Searching – Part 2 and Intro to Time Complexity (Algorithm Analysis)
Algorithm Design Techniques, Greedy Method – Knapsack Problem, Job Sequencing, Divide and Conquer Method – Quick Sort, Finding Maximum and Minimum, Dynamic.
Sorts, CompareTo Method and Strings
Sorting Mr. Jacobs.
Recursion Version 1.0.
Recitation 13 Searching and Sorting.
Programming in Java: lecture 10
Chapter 7 Sorting Spring 14
Algorithm Analysis CSE 2011 Winter September 2018.
Quicksort "There's nothing in your head the sorting hat can't see. So try me on and I will tell you where you ought to be." -The Sorting Hat, Harry Potter.
Description Given a linear collection of items x1, x2, x3,….,xn
Quicksort 1.
Quicksort and Mergesort
Advanced Sorting Methods: Shellsort
CO 303 Algorithm Analysis And Design Quicksort
CSC215 Lecture Algorithms.
Ch 7: Quicksort Ming-Te Chi
Sorting … and Insertion Sort.
Sub-Quadratic Sorting Algorithms
slides adapted from Marty Stepp
CSE 326: Data Structures Sorting
EE 312 Software Design and Implementation I
CSE 373 Data Structures and Algorithms
Algorithms: Design and Analysis
CSC 143 Java Sorting.
Data Structures & Algorithms
Quicksort.
CSE 332: Sorting II Spring 2016.
Sorting Taking an arbitrary permutation of n items and rearranging them into total order Sorting is, without doubt, the most fundamental algorithmic.
Searching and Sorting Hint at Asymptotic Complexity
Searching and Sorting Hint at Asymptotic Complexity
Advanced Sorting Methods: Shellsort
SIMPLE Sorting Sorting is a typical operation to put the elements in an array in order. Internal Sorts [for small data sets] selection bubble (exchange)
Presentation transcript:

Data Structures in Java with JUnit ©Rick Mercer Examples of Recursion Data Structures in Java with JUnit ©Rick Mercer

Converting Decimal Numbers to other bases Problem: Convert a decimal (base 10) number into other bases method Call Return convert(99, 2) 1100011 convert(99, 3) 10200 convert(99, 4) 1203 convert(99, 5) 344 convert(99, 6) 243 convert(99, 7) 201 convert(99, 8) 143 convert(99, 9) 120

Digits are multiplied by powers of the base 10, 8, 2, or whatever First: converting from other bases to decimal Decimal numbers multiply digits by powers of 10 950710 = 9 x 103 + 5 x 102 + 0 x 101 + 7 x 100 Octal numbers powers of 8 15678 = 1 x 83 + 5 x 82 + 6 x 81 + 7 x 80 = 512 + 320 + 48 + 7 = 88710 Binary numbers powers of 2 11012 = 1 x 23 + 1 x 22 + 0 x 21 + 1 x 20 = 8 + 4 + 0 + 1 = 1310

Converting base 10 to base 2 1) divide number (5) by new base(2), write remainder (1) 2) divide quotient (2), write new remainder (0) to left 3) divide quotient (1), write new remainder (1) to left __2_ 2 ) 5 Remainder = 1 __1_ 2 ) 2 Remainder = 0 __0_ 2 ) 1 Remainder = 1 Stop when the quotient is 0 510 = 1012 Print remainders in reverse order

Converting base 10 to base 8 1) divide number by new base (8), write remainder (1) 2) divide quotient (2), write new remainder (0) to left 3) divide quotient (1), write new remainder (1) to left _12_ 8 )99 Remainder = 3 __1_ 8 )12 Remainder = 4 __0_ 8 ) 1 Remainder = 1 Stop when the quotient is 0 9910 = 1438 Print remainders in reverse order

Possible Solutions We could either Iterative Algorithm store remainders in an array and reverse it or write out the remainders in reverse order have to postpone the output until we get quotient = 0 store result as a String (like a Recursion assignment) Iterative Algorithm while the decimal number > 0 { Divide the decimal number by the new base Set the decimal number = decimal number divided by the base Store the remainder to the left of any preceding remainders }

Recursive algorithm Base Case -- Recursive Case if decimal number being converted = 0 do nothing (or return "") Recursive case if decimal number being converted > 0 solve a simpler version of the problem use the quotient as the argument to the next call store the current remainder (number % base) in the correct place

One solution assertEquals("14", rf.convert(14, 10)); assertEquals("1100011", rf.convert(99, 2)); assertEquals("143", rf.convert(99, 8)); assertEquals("98", rf.convert(98, 10)); // 9*10+8 public String convert(int num, int base) { if (num == 0) return ""; else return convert(num/base, base) + (num%base); }

Hexadecimal, something we see as Computer Scientists Convert this algorithm to handle all base up through hexadecimal (base 16) 10 = A 11 = B 12 = C 13 = D 14 = E 15 = F

Quicksort: O(n log n) Sorting Quicksort was discovered by Tony Hoare 1962 Here is an outline of his famous algorithm: Pick one item from the array--call it the pivot Partition the items in the array around the pivot so all elements to the left are  to the pivot and all elements to the right are greater than the pivot Use recursion to sort the two partitions a snapshot pivot partition 1: items  pivot partition: items > pivot

Before and After Let's sort integers Pick the leftmost one (27) as the pivot value The array before call to partition(a, 0, n-1) Array looks like this after first partition is done 27 14 9 22 8 41 56 31 14 53 99 11 2 24 24 14 9 22 8 14 11 2 27 53 99 56 31 41 items < pivot pivot items > pivot

a[first]..a[split-1] <= a[split] The partition method partition divvies up a around the split and returns the position of the split, an integer in the range of 0..n-1 The postcondition of partition: a[first]..a[split-1] <= a[split] && a[split+1]..a[last] > a[split] Notes: May be more than 1 element equal to the pivot Put them in left partition could have been the right 27

Recursive call to sort smaller part of the array quickSort(a, split+1, last); // sort right QuickSort the right. At some point Pivot will be 53 Assume left portion is already sorted 24 14 9 22 8 14 11 2 27 53 99 56 31 41 left is already sorted, begin to sort part to the right of split 2 8 9 11 14 14 22 24 27 31 41 53 99 56 pivot items < pivot items > pivot

Complete the sort // sort left and right around new split quickSort(a, first, split-1); // sort right quickSort(a, split+1, last); 2 8 9 11 14 14 22 24 27 31 41 53 99 56 2 8 9 11 14 14 22 24 27 31 41 53 99 56 2 8 9 11 14 14 22 24 27 31 41 53 99 56 2 8 9 11 14 14 22 24 27 31 41 53 56 99 Entire array is now sorted

Start Over (i ==1) Now let's back up and start with empty partitions int partition(int a[], int first, int last) { int lastSmall = first; int i = (first + 1); // Beginning of unknowns Compare all items from a[i]..a[last] if a[i] > a[first] (the pivot), do nothing if a[i] <= a[first], swap a[lastSmall+1] with a[i] first lastSmall i unknown items (all are unknown--except first) 27 41 14 56 31 9 22 8 14 53 99 11 2 24

Result of the 1st loop iteration(i==2) The following array shows no changes were made in the array since a[i] <= a[first] was false So simply add 1 to i (i++)--create 2 partitions Now partition 1 has one element (the pivot 27) and partition 2 has 1 element (41) first lastSmall i unknown items 27 41 14 56 31 9 22 8 14 53 99 11 2 24 partition 1: all items <= pivot partition 2: all items > pivot

Result of the 2nd loop iteration(i==3) The following array shows a swap was made in the array since a[i] <= a[first] was true (14 < 27) a[i] (14) is swapped with a[lastSmall+1] (41) lastSmall gets incremented to point to the last element in partition 1 i gets incremented to reference 56 first lastSmall i unknown items 27 14 41 56 31 9 22 8 14 53 99 11 2 24 partition 1: all items <= pivot partition 2: all items > pivot

Result of the 3rd loop iteration(i==4) The following array shows no swap was made in the array since a[i] <= a[first] was false lastSmall does NOT get incremented i gets incremented to reference 31 first lastSmall i unknown items 27 14 41 56 31 9 22 8 14 53 99 11 2 24 partition 1: all items <= pivot partition 2: all items > pivot

Result of the 4th loop iteration(i==5) The following array shows no swap was made in the array since a[i] <= a[first] was false lastSmall does NOT get incremented i gets incremented to reference 9 first lastSmall i unknown items 27 14 41 56 31 9 22 8 14 53 99 11 2 24 partition 1: all items <= pivot partition 2: all items > pivot

Result of the 5th loop iteration(i==6) The following array shows a swap was made in the array since a[i] <= a[first] was true (9 < 27) a[i] (9) is swapped with a[lastSmall+1] (41) lastSmall gets incremented to point to the last element in partition 1 i++ points to the first unknown (22) first lastSmall i unknown items 27 14 9 56 31 41 22 8 14 53 99 11 2 24 partition 1: all items <= pivot partition 2: all items > pivot

i == 7 first lastSmall i unknown items 27 14 9 22 31 41 56 8 14 53 99 11 2 24 partition 1: all items <= pivot partition 2: all items > pivot

i == 8 first lastSmall i unknown 27 14 9 22 8 41 56 31 14 53 99 11 2 24 partition 1: all items <= pivot partition 2: all items > pivot

i == 9 first lastSmall i unknown 27 14 9 22 8 14 56 31 41 53 99 11 2 24 partition 1: all items <= pivot partition 2: all items > pivot

i == 10 first lastSmall i unknown 27 14 9 22 8 14 56 31 41 53 99 11 2 24 partition 1: all items <= pivot partition 2: all items > pivot

i == 11 first lastSmall i unknown 27 14 9 22 8 14 56 31 41 53 99 11 2 24 partition 1: all items <= pivot partition 2: all items > pivot

i == 12 first lastSmall i unknown 27 14 9 22 8 14 11 31 41 53 99 56 2 24 partition 1: all items <= pivot partition 2: all items > pivot

i == 13 first lastSmall i unknown 27 14 9 22 8 14 11 2 41 53 99 56 31 24 partition 1: all items <= pivot partition 2: all items > pivot

Result of the 14th loop iteration(i==14) The following array shows what happens after traversing the entire array with this loop (i>last): for (i = first + 1; i <= last; i++) { if(a[i] <= a[first] ) { lastSmall++; swapElements(a, lastSmall, i); } first lastSmall i 27 14 9 22 8 14 11 2 24 53 99 56 31 41 partition 1: all items <= pivot partition 2: all items > pivot

Post Loop Detail Now place the pivot into where we expect the pivot to be: in-between the two partitions swapElements( a, first, lastSmall ); Then we can return lastSmall for the next call return lastSmall; first lastSmall (pivot position) 24 14 9 22 8 14 11 2 27 53 99 56 31 41 partition 1: all items <= pivot partition 2: all items > pivot

quickSort is called like this: quickSort(a, 0, n-1) void quickSort(int a[], int first, int last) { // precondition: a is an array to be sorted from // a[first]..a[last] if(first >= last) return; // Done: we have an empty array // The difficult algorithm is in partition int split = partition ( a, first, last ); // Recursively Quicksort left, then right quickSort(a, first, split-1); // sort left quickSort(a, split+1, last); // sort right // post: the array a is sorted }

Analyzing Quicksort The critical statement happens in the comparison of the for loop of the partition function if(a[i] <= a[first]) So how many times is partition called? And what are the values for first and last (# comparisons)? If the pivot element is near the mode, we don't have many calls to QuickSort, it is O(log n) 37

The best of Quicksort, the worst of Quicksort In the best case (1st element is always middle value) with 7 elements, call partition 3 times first == 0, last == 6 // 6 comparisons first == 0, last == 2 // 2 comparisons first == 4, last == 6 // 2 comparisons In the worst case, (sorted array), with 7 elements, partition is called first == 1, last == 6 // 5 comparisons first == 2, last == 6 // 4 comparisons first == 3, last == 6 // 3 comparisons first == 5, last == 6 // 1 comparison 38

Best Case: [ 4, 1, 3, 2, 6, 5, 7 ] [ 2, 1, 3, 4, 6, 5, 7 ] [ 2, 1, 3] [ 6, 5, 7 ] [ 1, 2, 3] [ 5, 6, 7 ] [1] [3] [5] [7]

Worst Case [ 1, 2, 3, 4, 5, 6, 7] [] [2, 3, 4, 5, 6, 7] [] [3, 4, 5, 6, 7] [] [4, 5, 6, 7] [] [5, 6, 7] [] [6, 7] [] [7] [] []

The Best and Worst continued So in the worst case, partition is called n-1 times: (n-1)+(n-2)+ ... + 1 comparisons = O(n2) The worst case of Quicksort may be the same as Selection Sort, which is O(n2) Quicksort is used because of its best and average cases 39