CSCI 121: Searching & Sorting Data

Transcription

1 CSCI 121: Searching & Sorting Data

2 Searching a list Let s consider the work involved in Python s execution of it might rely on code like this: y in xs def search(y,xs): i, n = 0, len(xs) while i < n: if xs[i] == y: return True i += 1 return False Its running time depends on where y sits in xs, if at all. For an unsuccessful search it is Θ(n). We can t improve on this, it seems, without any knowledge of the parameters, as all values have to be checked in this case

3 Searching a ed list But what if the list is ed so that xs[0] xs[1] xs[n-1] Then we can rely on a scheme called binary search. We inspect the item in the middle If that value is larger than y, then we don t have to check the right half. If that value is smaller than y, then we don t have to check the left half. And maybe we get lucky and find y at that middle location.

4 Code attempt using slices def slice_search(y,xs): if len(xs) > 0: m = (len(xs)-1) // 2 # compute a middle index if y == xs[m]: # found it! return True elif y < xs[m]: return slice_search(y,xs[:m]) else: # larger, eliminate the left return slice_search(y,xs[m+1:]) else: return False # smaller, eliminate the right # nothing left

5 Code attempt using slices def slice_search(y,xs): if len(xs) > 0: m = (len(xs)-1) // 2 # compute a middle index if y == xs[m]: # found it! return True elif y < xs[m]: return slice_search(y,xs[:m]) else: # larger, eliminate the left return slice_search(y,xs[m+1:]) else: return False # smaller, eliminate the right # nothing left How many recursive calls to search a list of length n?

6 Code attempt using slices def slice_search(y,xs): if xs == []: return False m = (len(xs)-1) // 2 if y == xs[m]: return True elif y < xs[m]: return slice_search(y,xs[:m]) else: return slice_search(y,xs[m+1:]) How many recursive calls to search a list of length n? Each check eliminates at least half of the values.

7 Code attempt using slices def slice_search(y,xs): if xs == []: return False m = (len(xs)-1) // 2 if y == xs[m]: return True elif y < xs[m]: return slice_search(y,xs[:m]) else: return slice_search(y,xs[m+1:]) How many recursive calls to search a list of length n? Each check eliminates at least half of the values. Thus, O(log 2 n) calls are made. Note: the base doesn t matter here because of O.

8 Code attempt using slices def slice_search(y,xs): if xs == []: return False m = (len(xs)-1) // 2 if y == xs[m]: return True elif y < xs[m]: return slice_search(y,xs[:m]) else: return slice_search(y,xs[m+1:]) Is the running time O(log 2 n)?

9 Code attempt using slices def slice_search(y,xs): if xs == []: return False m = (len(xs)-1) // 2 if y == xs[m]: return True elif y < xs[m]: return slice_search(y,xs[:m]) else: return slice_search(y,xs[m+1:]) Is the running time O(log 2 n)? NO. Taking a slice of a list requires making a copy of that sliced portion. If the first check fails to find y then taking that first slice uses Θ(n) time.

10 Code attempt using slices def slice_search(y,xs): if xs == []: return False m = (len(xs)-1) // 2 if y == xs[m]: return True elif y < xs[m]: return slice_search(y,xs[:m]) else: return slice_search(y,xs[m+1:]) This is still a nice idea. To get rid of slicing we instead track the kept region by using a left and a right index

11 Recursive binary search def binary_search(y,xs,l,r): if l <= r: m = (l + r) // 2 if y == xs[m]: return True elif y < xs[m]: return binary_search(y,xs,l,m-1) else: return binary_search(y,xs,m+1,r) else: return False We start the search with binary_search(y,xs,0,len(xs)-1) The running time is O(log 2 n) for a list of length n.

12 Recursive binary search def binary_search(y,xs,l,r): if l <= r: m = (l + r) // 2 if y == xs[m]: return True elif y < xs[m]: return binary_search(y,xs,l,m-1) else: return binary_search(y,xs,m+1,r) else: return False Since binary_search is tail recursive we can easily write the code using a loop instead.

13 Iterative binary search def binary_search(y,xs): l, r = 0, len(xs)-1 while l <= r: m = (l + r) // 2 if y == xs[m]: return True elif y < xs[m]: r = m-1 else: l = m+1 return False This is the same idea, built from the recursive notion. The running time is O(log 2 n) for a list of length n.

14 Iterative binary search def binary_search(y,xs): l, r = 0, len(xs)-1 while l <= r: m = (l + r) // 2 if y == xs[m]: return True elif y < xs[m]: r = m-1 else: l = m+1 return False

15 Iterative binary search def binary_search(y,xs): left, right = 0, len(xs)-1 while left <= right: middle = (left + right) // 2 if y == xs[middle]: return True elif y < xs[middle]: r = middle-1 else: l = middle+1 return False

16 Bubble Sort With bubble we make a series of left-to-right passes, examining neighboring values and bubbling larger values so that they rise to the right: def bubble_(xs): n = len(xs) for scan in range(1,n): i = 0 while i < n - scan: if xs[i+1] > xs[i]: xs[i],xs[i+1] = xs[i+1],xs[i] i += 1

17 Bubble Sort With bubble we make a series of left-to-right passes, examining neighboring values and bubbling larger values so that they rise to the right: def bubble_(xs): n = len(xs) for scan in range(1,n): i = 0 while i < n - scan: if xs[i+1] > xs[i]: xs[i],xs[i+1] = xs[i+1],xs[i] i += 1 This means that we only need n-1 passes.

18 Bubble Sort With bubble we make a series of left-to-right passes, examining neighboring values and bubbling larger values so that they rise to the right: def bubble_(xs): n = len(xs) for scan in range(1,n): i = 0 while i < n - scan: if xs[i+1] > xs[i]: xs[i],xs[i+1] = xs[i+1],xs[i] i += 1 This means that we only need n-1 passes. This means that we can stop each pass early.

19 Bubble Sort def bubble_(xs): n = len(xs) for scan in range(1,n): i = 0 while i < n - scan: if xs[i+1] > xs[i]: xs[i],xs[i+1] = xs[i+1],xs[i] i += 1 What is the running time of bubble?

20 Bubble Sort def bubble_(xs): n = len(xs) for scan in range(1,n): i = 0 while i < n - scan: if xs[i+1] > xs[i]: xs[i],xs[i+1] = xs[i+1],xs[i] i += 1 What is the running time of bubble? If the list is in reverse ed order, then we have to bubble up over xs[:-scan]

21 Bubble Sort def bubble_(xs): n = len(xs) for scan in range(1,n): i = 0 while i < n - scan: if xs[i+1] > xs[i]: xs[i],xs[i+1] = xs[i+1],xs[i] i += 1 What is the running time of bubble? If the list is in reverse ed order, then we have to bubble up over xs[:-scan] It makes n - 1 swaps on the first pass, then n - 2 swaps, then n - 3 swaps,

22 Bubble Sort def bubble_(xs): n = len(xs) for scan in range(1,n): i = 0 while i < n - scan: if xs[i+1] > xs[i]: xs[i],xs[i+1] = xs[i+1],xs[i] i += 1 What is the running time of bubble? If the list is in reverse ed order, then we have to bubble up over xs[:-scan] It makes n - 1 swaps on the first pass, then n - 2 swaps, then n - 3 swaps,

23 Bubble Sort Analysis def bubble_(xs): n = len(xs) for scan in range(1,n): i = 0 while i < n - scan: if xs[i+1] > xs[i]: xs[i],xs[i+1] = xs[i+1],xs[i] i += 1 What is the running time of bubble? The total number of swaps is n(n-1)/2 = (n - 1) + (n - 2) The running time is Θ(n2) in that worst case.

24 Selection Sort Make a series of scans, with the first scan placing the minimum in xs[0], a second scan placing the next smallest item in xs[1], and so forth. Each scan involves looking at position idx rightward, and finding the position min_idx of the smallest item within xs[idx:] We swap xs[idx] with xs[min_idx],then perform the next scan. def selection_(xs): n = len(xs) idx = 0 while idx < n - 1: min_idx = idx scan_idx = idx + 1 while scan_idx < n: if xs[scan_idx] < xs[min_idx]: min_idx = scan_idx scan_idx = scan_idx + 1 xs[idx],xs[min_idx] = xs[min_idx],xs[idx] idx = idx + 1

25 Summary A similar analysis for selection shows it runs in Θ(n2) time in the worst case. Both bubble and selection are quadratic time algorithms.

26 CSCI 121: Sorting in Sub-Quadratic Time

27 Sorting so far Bubble and selection run in quadratic time. Fine for small-sized lists but too slow for very large lists. Two famous s use a divide and conquer recursive approach. Merge and randomized quick are Θ(n log n) s. They split the work in half *, recursively work on each half. We use expected running time for the randomized quick, not worst case. * Roughly speaking, and on average, in the case of randomized quick.

28 Merge ~ * & ^ # ^ & * & *

29 slice the list into two halves Merge ~ * & ^ # ^ & * & * split! ~ * & ^ # ^ & * & *

30 slice the list into two halves each half Merge ~ * & ^ # ^ & * & * split! ~ * & ^ # ^ & * & *

31 slice the list into two halves each half Merge ~ * & ^ # ^ & * & * split! ~ * & ^ # ^ & * & * < < < < < <

32 slice the list into two halves each half Merge ~ * & ^ # ^ & * & * ~ * & ^ # ^ < < < < < < split! & * & * < < < < < <

33 Merge slice the list into two halves each half merge the two ed lists into a single ed list ~ * & ^ # ^ & * & * ~ * & ^ # ^ split! & * & * < < < < < < < < < < < < merge! < < < < < < < < < < <

34 Merge slice the list into two halves each half merge the two ed lists into a single ed list ~ * & ^ # ^ & * & * ~ * & ^ # ^ split! & * & * < < < < < < < < < < < < merge! < < < < < < < < < < <

35 Merge slice the list into two halves each half merge the two ed lists into a single ed list ~ * & ^ # ^ & * & * ~ * & ^ # ^ split! & * & * < < < < < < < < < < < < merge! < < < < < < < < < < <

36 Merge slice the list into two halves each half merge the two ed lists into a single ed list ~ * & ^ # ^ & * & * ~ * & ^ # ^ split! & * & * < < < < < < < < < < < < merge! < < < < < < < < < < <

37 Merge slice the list into two halves each half merge the two ed lists into a single ed list ~ * & ^ # ^ & * & * ~ * & ^ # ^ split! & * & * < < < < < < < < < < < < merge! < < < < < < < < < < <

38 Merge slice the list into two halves each half merge the two ed lists into a single ed list ~ * & ^ # ^ & * & * ~ * & ^ # ^ split! & * & * < < < < < < < < < < < < merge! < < < < < < < < < < <

39 Merge slice the list into two halves each half merge the two ed lists into a single ed list ~ * & ^ # ^ & * & * ~ * & ^ # ^ split! & * & * < < < < < < < < < < < < merge! < < < < < < < < < < < Voilà!

40 Merge

41 slice the list into two halves Merge split!

42 slice the list into two halves each half Merge split!

43 slice the list into two halves each half Merge split!

44 slice the list into two halves each half Merge split!

45 Merge slice the list into two halves each half merge the two ed lists into a single ed list split! merge!

46 Merge slice the list into two halves each half merge the two ed lists into a single ed list split! merge!

47 Merge slice the list into two halves each half merge the two ed lists into a single ed list split! merge!

48 Merge slice the list into two halves each half merge the two ed lists into a single ed list split! merge!

49 Merge slice the list into two halves each half merge the two ed lists into a single ed list split! merge!

50 Merge slice the list into two halves each half merge the two ed lists into a single ed list split! merge!

51 Merge slice the list into two halves each half merge the two ed lists into a single ed list split! merge!

52 Merge slice the list into two halves each half merge the two ed lists into a single ed list split! merge! Et voilà!

53 Merge def merge(xs): if len(xs) > 1: middle = len(xs) // 2 lefts = xs[:middle] rights = xs[middle:] merge(lefts) merge(rights) merge(lefts,rights,xs)

54 Merge def merge(xs): if len(xs) > 1: middle = len(xs) // 2 lefts = xs[:middle] rights = xs[middle:] merge(lefts) merge(rights) merge(lefts,rights,xs) def merge(ls,rs,xs): xi, li, ri = 0, 0, 0 while xi < len(xs): if ls[li] <= rs[ri]: xs[xi] = ls[li] li += 1 else: xs[xi] = rs[ri] ri += 1 xi += 1

55 Merge def merge(xs): if len(xs) > 1: middle = len(xs) // 2 lefts = xs[:middle] rights = xs[middle:] merge(lefts) merge(rights) merge(lefts,rights,xs) def merge(ls,rs,xs): xi, li, ri = 0, 0, 0 while xi < len(xs): if ls[li] <= rs[ri]: xs[xi] = ls[li] li += 1 else: xs[xi] = rs[ri] ri += 1 xi += 1 This is not quite correct => We might run out of ls and rs.

56 Merge def merge(xs): if len(xs) > 1: middle = len(xs) // 2 lefts = xs[:middle] rights = xs[middle:] merge(lefts) merge(rights) merge(lefts,rights,xs) def merge(ls,rs,xs): xi, li, ri = 0, 0, 0 while xi < len(xs): l_valid, r_valid = li < len(ls), ri < len(rs) if l_valid and ((not r_valid) or ls[li] <= rs[ri]): xs[xi] = ls[li] li += 1 else: xs[xi] = rs[ri] ri += 1 xi += 1

57 Quick

58 Quick pick a pivot value pick

59 Quick pick a pivot value partition around the pivot into lessers and greaters pick partition

60 Quick pick a pivot value partition around the pivot into lessers and greaters the lessers pick partition

61 Quick pick a pivot value partition around the pivot into lessers and greaters the lessers; the greaters pick partition

62 Quick pick a pivot value partition around the pivot into lessers and greaters the lessers; the greaters pick partition Voici.

63 Partitioning To partition, we rearrange according to the pivot value. We build up a lesser region and a greater region. Here is a snapshot of that work, in progress: p z > z???????????????????????????? p??? > p???? pivot value

64 Partitioning To partition, we rearrange according to the pivot value. We build up a lesser region and a greater region. Here is a snapshot of that work, in progress: >p ter s les se rs p gr ea piv ot va lue p??????????

65 Partitioning We scan the list by an index, from left to right. We place each value by comparing it with the pivot. There are 2 cases: less than or equal; greater than ter s rs les se v????????? ind ex >p p gr ea piv ot va lue p

66 Less than or equal case If the next value is less than or equal to the pivot ter s rs les se v????????? ind ex >p p gr ea piv ot va lue p

67 Less than or equal case If the next value is less than or equal to the pivot then we swap it with the leftmost of the greaters. swap! ter s rs les se v????????? ind ex >p p gr ea piv ot va lue p

68 Less than or equal case If the next value is less than or equal to the pivot then we swap it with the leftmost of the greaters. swap! >p????????? ind ex v ter s les se rs p gr ea piv ot va lue p

69 Less than or equal case If the next value is less than or equal to the pivot then we swap it with the leftmost of the greaters and advance the index.????????? ind ex >p v ter s les se rs p gr ea piv ot va lue p

70 Greater than case If the next value is greater than the pivot ter s rs les se v???????? ind ex >p p gr ea piv ot va lue p

71 Greater than case If the next value is greater than the pivot then there is no rearranging to do. ter s rs les se v???????? ind ex >p p gr ea piv ot va lue p

72 Greater than case If the next value is greater than the pivot then there is no rearranging to do. We can just advance the index. ter s rs les se v???????? ind ex >p p gr ea piv ot va lue p

73 Quick def quick(xs): quick_helper(xs, 0, len(xs)-1) def quick_helper(xs, left, right): if left < right: pivot = partition(xs, left, right) quick_helper(xs, left, pivot - 1) quick_helper(xs, pivot + 1, right) def partition(xs, first, last): pivot, pivot_value = first, xs[first] i = first + 1 while i <= last: if xs[i] <= pivot_value: xs[pivot+1],xs[i] = xs[i],xs[pivot+1] pivot = pivot + 1 i += 1 xs[first],xs[pivot] = xs[pivot],xs[first] return pivot