Sorting and Searching. Lecture 14

Transcription

1 Sorting and Searching Lecture 14

2 Announcements WS4 - Due Today PS3 - Due next Tuesday. This one increases in difficulty as you move through it. Start now!

3 Warm-up #1: What are the elements of array numbers in the main function that are printed? function main(): void { let numbers: number[] = [3, 9, 4, 2, 1]; movebackward(numbers, 2); print(numbers); } function movebackward(a: number[], i: number): void { let temp: number = a[i]; a[i] = a[i - 1]; a[i - 1] = temp; }

4 Warm-up #2: What is printed when this code runs? function main(): void { let numbers: number[] = [101, 110, 401, 110, 110, 110]; print(find(numbers, 110)); } function find(haystack: number[], needle: number): boolean { for (let i: number = 0; i < haystack.length; i++) { if (haystack[i] === needle) { return true; } } return false; } main();

5 World's 2 nd Worst Magic Trick

6 Follow-along: Sort by Low Temperature Open 00-comparator-sort-app.ts Notice we are importing: Classes: WeatherRow Functions: bytemplow, bytemphigh, and printrows Take a look at the bytemplow comparator function implementation Let's sort the data using bytemplow

7 print("sorted bytemplow"); // TODO: Sort Data using bytemplow comparator let comparator: Comparator<WeatherRow> = bytemplow; data.sort(comparator); printrows(data, 3);

8 The Comparator<T> Functional Interface A functional interface for comparing two objects of type T for sorting and searching Its signature is: (a: T, b: T): number; i.e. an implementation of Comparator<WeatherRow>: function bytemplow(a: WeatherRow, b: WeatherRow): number { // TODO: Compare a and b } Returns: A negative number when a comes before b A positive number when a comes after b Zero when a is same order as b and order doesn't matter

9 Use Constants to avoid "Magic Numbers" A magic number is a nameless, literal value in code like comparator's -1 or 1 Hard to remember what they mean! "What does this -1 mean here again?" Causes larger projects to become more difficult to maintain. Best practice: Define constants to give meaning to magic numbers. A constant is just a variable whose value cannot be reassigned Here's how you declare a constant in TypeScript: const <NAME>: <type> = <value>; It is conventional to name constants in ALL_UPPERCASE_LETTERS and separate words with _'s const A_BEFORE_B: number = -1;

10 Array's sort method Every array of type T[] has a method named sort Here's its signature: T[] sort(comparator<t> comparator) If we call sort on an array object, and tell it how to compare any two elements using a Comparator function, the array will be sorted for us! Disclaimer: sort modifies the original array and returns a reference to the original array. It does not create and return a new array like filter and map.

11 Sorting Order Notice that bylowtemp is sorting in ascending order Lowest to Highest A-Z How could we implement byhightemp to sort in descending order? Highest to Lowest Z-A What's the difference? A Comparator's logic decides whether sorting is ascending/descending

12 Hands-on: Sort by High Temperature Descending 1. Open comparators.ts and find the byhightemp function 2. Fix its logic such that: 1. When a's temphigh is larger than b's, the function will return A_BEFORE_B (descending!) 2. When a's temphigh is smaller than b's, return A_AFTER_B 3. Otherwise, return A_SAME_AS_B 3. From 00-comparator-sort-app.ts, at TODO #2, sort the data using the byhightemp comparator function 4. Check-in when you see the 3 hottest days in the data set printing in descending order

13 export function bytemphigh(a: WeatherRow, b: WeatherRow): number { if (a.temphigh > b.temphigh) { return A_BEFORE_B; } else if (a.temphigh < b.temphigh) { return A_AFTER_B; } else { return A_SAME_AS_B; } } print("sorted bytemphigh"); // TODO #2 Sort Data using bytemphigh comparator data.sort(bytemphigh); printrows(data, 3);

14 Switching gears: Searching

15 Linear Search Start from one end of an array "haystack". Visit each element one-by-one until you find your "needle". Made past the end? No match!

16 The Linear Search Algorithm Be El Folt I Jog Kid Loo Mom Pop The Ug Um Us Vim Win Yes i Does the word Yes exist in this array of Strings?

17 Follow-Along: Let's Implement Linear Search Open 01-linear-search-app.ts We'll be working with the CSV file words.csv which has 77,000 words in it We'll implement the linearsearch function together

18 function linearsearch(haystack: string[], needle: string, compare: Comparator<string>): boolean { } for (let i: number = 0; i < haystack.length; i++) { } let comparison: number = compare(needle, haystack[i]); comparisons++; // Count this as a comparison if (comparison === A_SAME_AS_B) { return true; } return false;

19 How many steps does it take to find a word using a Linear Search algorithm? If we ran this with enough words selected at random, you would expect it takes on average: _words.length / 2 or N / 2 Why? Some words will be found in few steps the first half of the list, and others will be found in many steps in the second half of the list. When evaluating runtime characteristics of an algorithm, computer scientists tend to waive their hands and approximate. We classify linear search as an O(N) algorithm using big oh notation. Given a search space of N items, this algorithm will complete in about N steps.

20 Can we do better? Is this how you would find a word in a dictionary that starts with another word? Start with aardvark and scan your finger through each word until matching. What is it about a dictionary helps us do better? Dictionaries are sorted!

21 Aside: Number Guessing Game Think of a number between 1 and 64 Have your friend guess it Say "higher" or "lower" in response Count the # of guesses it takes! See who takes fewer guesses Check-in on PollEv.com/comp110

22 Introducing: Binary Search Requirement: Elements must be SORTED! Why are sorting algos important? So we can search efficiently! Algo: Start in the middle, compare with what we re looking for: Too big? Look only at the smaller half. Too small? Look only at the larger half. Step Numbers Left Intuition: at every step we cut the search space in half...

23 The Binary Search Algorithm Be El Folt I Jog Kid Loo Mom Pop The Ug Um Us Vim Win Yes Does the word Folt exist in this array of Strings?

24 Low High The Binary Search Algorithm Be El I Jog Kid Loo Mom Pop The Ug Um Us Vim Win Yes Looking for: Folt low 0 high 15 middle?

25 Low Middle High The Binary Search Algorithm Be El I Jog Kid Loo Mom Pop The Ug Um Us Vim Win Yes Looking for: Folt low 0 high 15 middle 7

26 Low Middle High The Binary Search Algorithm Lower Be El I Jog Kid Loo Mom Pop The Ug Um Us Vim Win Yes Looking for: Folt low 0 high 15 middle 7

27 Low Middle High The Binary Search Algorithm Be El I Jog Kid Loo Mom Pop The Ug Um Us Vim Win Yes Looking for: Folt low 0 high 6 middle?

28 Low High Middle The Binary Search Algorithm Be El I Jog Kid Loo Mom Pop The Ug Um Us Vim Win Yes Looking for: Folt low 0 high 6 middle 3

29 Low Middle High The Binary Search Algorithm Higher Be El Dog Jog Kid Loo Mom Pop The Ug Um Us Vim Win Yes Looking for: Folt low 0 high 6 middle 3

30 Low Middle High The Binary Search Algorithm Be El Dog Jog Kid Loo Mom Pop The Ug Um Us Vim Win Yes Looking for: Folt low 4 high 6 middle 3

31 Middle Low High The Binary Search Algorithm Be El Dog Jog Kid Loo Mom Pop The Ug Um Us Vim Win Yes Looking for: Folt low 4 high 6 middle 5

32 Low Middle High The Binary Search Algorithm Lower Be El Dog Jog Kid Loo Mom Pop The Ug Um Us Vim Win Yes Looking for: Folt low 4 high 6 middle 5

33 Low Middle High The Binary Search Algorithm Be El Dog Jog Kid Loo Mom Pop The Ug Um Us Vim Win Yes Looking for: Folt low 4 high 4 middle?

34 Low High Middle The Binary Search Algorithm Be El Dog Jog Kid Loo Mom Pop The Ug Um Us Vim Win Yes Looking for: Folt low 4 high 4 middle 4

35 Middle Low High The Binary Search Algorithm Be El Dog Jog Kid Loo Mom Pop The Ug Um Us Vim Win Yes Looking for: Folt low 4 high 4 middle 4

36 How do we calculate the next middle? Low High Middle middle = Math.floor((low + high) / 2) Calling the Math.floor method will cause any decimal value to always be rounded down. This winds up being useful because arrays are 0-indexed. Imagine the case of the 2-element array. Low would be 0, high would be 1, and so the first middle would be: Math.floor(1 / 2). We choose to try 0 first.

37 Follow-along: Let's Implement Binary Search Open 03-binary-search-app.ts Let's implement the missing logic in the binarysearch function together!

38 function binarysearch(haystack: string[], needle: string, compare: Comparator<string>): boolean { let low: number = 0; let high: number = haystack.length - 1; while (low <= high) { let middle: number = Math.floor((low + high) / 2); let comparison: number = compare(needle, haystack[middle]); comparisons++; // Count this call to comparator } // TODO: Implement Correct Logic if (comparison <= A_BEFORE_B) { // We need to guess lower! high = middle - 1; } else if (comparison >= A_AFTER_B) { // We need to guess higher! low = middle + 1; } else { return true; } } // Needle was not found! return false;

39 How many steps does it take to find a word using the Binary Search algorithm? If we ran this with enough words selected at random, you would expect it takes ~ log 2 (words.length) We classify binary search as an O(log 2 (N)) Given a search space of N, this algorithm will complete in log 2 (N) steps. The best algorithms in computer science tend to have logarithmic solutions. Step Words Left 0 77, , , , , , ,

40 If we had an array with every one of the 7 billion humans on Earth's names arranged in order, how many steps would it take to find one using binary search? 33 steps at most. 2^32 is 4.2 billion 2^33 is 8.5 billion

41 So how does a sorting algorithm work?

42 Sorting Algorithms Array Sort Algorithm Sorted List One of Computer Science's oldest bodies of work! Insertion Sort Heap Sort There are many sorting algorithms each with pros/cons. Use a language's built-in sort functionality! You should very rarely, if ever, implement your own sorting algorithm in a real-world project Sorting is a solved problem and these algos take time to debug

43 "Magic Trick" - Reveal By looking at only 2 cards at a time, I was able to sort a List of cards How?!? A Sorting Algorithm Programming languages have built-in sorting algorithms......all you typically need to sort data is provide a Comparator. We looked at a few example implementations of the Comparator interface Let's try implementing a simple sort algorithm!

44 Insertion Sort Algorithm Overview 1. Start from the front of an array 2. "Hat" is the next element. No next element? Go to step Move hat backwards to the correctly sorted position in the array. 4. Tada!

45 Insertion Sort Algorithm Overview 1. Start from the front of an array 2. "Hat" is the next element. No next element? Go to step Relative to the element before it, should "hat" move backwards? 1. Yes? Move it backward one position! Repeat step No? It's in its correctly sorted position! Go to step Tada! A fully sorted array!

46 How do we know an element should move backward? Base case: it is already the first element of the array, at index 0. Cannot move backward. Otherwise: we compare it to the previous element using a Comparator comparator(a[hat], a[hat-1]) <= A_BEFORE_B Reminder: A_BEFORE_B is the constant -1 When a negative number is returned after comparing the current element a[hat] as the first parameter to the previous element a[hat-1] as the second parameter, it means the current element should move backward to be ordered correctly.

47 Follow-along: Implement Insertion Sort function sort(a: number[], compare: Comparator<number>): number[] { for (let i: number = 0; i < a.length; i++) { let hat: number = i; // TODO: Implement the logic to move a card backward while (hat > 0 && compare(a[hat], a[hat - 1]) <= A_BEFORE_B) { movebackward(a, hat); hat--; } } return a; }

48 Insertion Sort vs. Array's built-in sort method Both algorithms achieve the same goal of sorting an array. However, the language's sort algorithm is much faster than insertion sort. Reminder: Use your programming language's built-in sorting algorithms!