CSE 115. Introduction to Computer Science I

Transcription

1 CSE 115 Introduction to Computer Science I

2 Road map Review Linear vs Binary Search Selection vs Merge Sort Defining Custom Sorts Empirical Demo

3 Music Rating App User Browser Navigates to the app's URL The Internet HTTP Request for path "/" # return static file: # index.html index.html downloaded HTTP Request for path # return static file: # mycode.js mycode.js downloaded JSON formatted songs and ratings -Convert to HTML and set as the innerhtml of the songs div AJAX HTTP GET Request for path # call get_songs() in the # ratings.py file

4 Music Rating App User User enters a new song and clicks button JSON formatted songs and ratings -Convert to HTML and set as the innerhtml of the songs div The Internet AJAX HTTP POST Request for path "/add_song" # -read the new song # -call add_song from the # ratings.py file # -the song is appended to # songs.csv User clicks a rating button JSON formatted songs and ratings -Convert to HTML and set as the innerhtml of the songs div AJAX HTTP POST Request for path "/rate_song" Handle POST requests until the user leaves the # -call rate_song from the # ratings.py file # -the rating is appended to # ratings.csv

5 Music Rating App - Expansions Prevent Multiple Ratings Users can rate the same songs as many times as they can click (or write a program to spam ratings) Discussion: How would we prevent this? Update Titles and Artists If the user to add a song uses the wrong title/artist, it cannot be updated later Could make it so any user can edit these fields Reviews Add reviews to the ratings so users can share their opinions instead of just numbers

6 Music Rating App - Expansions Style Add star ratings instead of displaying all ratings for each song Add color and CSS Sorting (module 4 foreshadow) Sort the songs based on average rating, artist, or number of ratings Security (module 4 foreshadow) This site is not secure! Vulnerable to HTML/JavaScript injection No encryption of HTTP requests Preventing multiple ratings without compromising privacy

7 Road map Review Linear vs Binary Search Selection vs Merge Sort Defining Custom Sorts Empirical Demo

8 Algorithms An algorithm is "a set of rules for solving a problem in a finite number of steps"

9 Road map Exam return Review Algorithms Linear vs Binary Search Selection vs Merge Sort Defining Custom Sorts Empirical Demo

10 Linear search def linearsearch(x, Z): for Y in X: if Y == Z: return True return False

11 Linear search def linearsearch(x, Z): for Y in X: if Y == Z: return True return False N-1 "AR" "BS" "BQ" "CD" "FW" "GM" "KD" "LP" "JK" "KD" IS "AR" == "KD"?

12 Linear search def linearsearch(x, Z): for Y in X: if Y == Z: return True return False N-1 "AR" "BS" "BQ" "CD" "FW" "GM" "KD" "LP" "JK" "KD" IS "BS" == "KD"?

13 Linear search def linearsearch(x, Z): for Y in X: if Y == Z: return True return False N-1 "AR" "BS" "BQ" "CD" "FW" "GM" "KD" "LP" "JK" "KD" IS "BQ" == "KD"?

14 Linear search def linearsearch(x, Z): for Y in X: if Y == Z: return True return False N-1 "AR" "BS" "BQ" "CD" "FW" "GM" "KD" "LP" "JK" "KD" IS "CD" == "KD"?

15 Linear search def linearsearch(x, Z): for Y in X: if Y == Z: return True return False N-1 "AR" "BS" "BQ" "CD" "FW" "GM" "KD" "LP" "JK" "KD" IS "FW" == "KD"?

16 Linear search def linearsearch(x, Z): for Y in X: if Y == Z: return True return False N-1 "AR" "BS" "BQ" "CD" "FW" "GM" "KD" "LP" "JK" "KD" IS "GM" == "KD"?

17 Linear search def linearsearch(x, Z): for Y in X: if Y == Z: return True return False N-1 "AR" "BS" "BQ" "CD" "FW" "GM" "KD" "LP" "JK" "KD" IS "KD" == "KD"?

18 Linear search def linearsearch(x, Z): for Y in X: if Y == Z: return True return False N-1 "AR" "BS" "BQ" "CD" "FW" "GM" "KD" "LP" "JK" "KD" IS "KD" == "KD"? return True

19 Binary search def binarysearch(x, Z): left = 0 right = len(x) while (right - left) > 0: mid = (left + right)//2 if Z < X[mid]: right = mid elif Z > X[mid]: left = mid+1 else: return True return False

20 def binarysearch(x, Z): left = 0 right = len(x) while (right - left) > 0: mid = (left + right)//2 if Z < X[mid]: right = mid elif Z > X[mid]: left = mid+1 else: return True return False Binary search "AR" "BS" "BQ" "CD" "FW" "GM" "KD" "LP" "JK" "KD" "KD" > "FW"

21 def binarysearch(x, Z): left = 0 right = len(x) while (right - left) > 0: mid = (left + right)//2 if Z < X[mid]: right = mid elif Z > X[mid]: left = mid+1 else: return True return False Binary search "AR" "BS" "BQ" "CD" "FW" "GM" "KD" "LP" "JK" "KD" "KD" == "KD"

22 def binarysearch(x, Z): left = 0 right = len(x) while (right - left) > 0: mid = (left + right)//2 if Z < X[mid]: right = mid elif Z > X[mid]: left = mid+1 else: return True return False Binary search "AR" "BS" "BQ" "CD" "FW" "GM" "KD" "LP" "JK" "KD" "KD" == "KD" return True

23 Linear vs Binary search # comparisons are a good measure of work x == y comparison eliminates 1 item from consideration If input has N items, in worst case we need to do N comparisons x < y, x > y comparisons eliminate half of items from consideration If input has N items, in worst case we need to do log2(n) comparisons

24 Road map Exam return Review Algorithms Linear vs Binary Search Selection vs Merge Sort Defining Custom Sorts Empirical Demo

25 Sorting Given a sequence of values that can be ordered, sorting involves rearranging these values so they go from smallest to largest (or largest to smallest). Example: [17, 93, 12, 44, 82, 81, 22, 73] Sorting rearranges items: all mixed up [12, 17, 22, 44, 73, 81, 82, 93] smallest increasing largest

26 Selection sort Given a list of values, repeatedly select the smallest value and push it to the end of a list of sorted values.

27 Selection sort UNSORTED LIST [17, 93, 12, 44, 82, 81, 22, 73] [] SORTED LIST

28 Selection sort UNSORTED LIST [17, 93, 12, 44, 82, 81, 22, 73] Smallest from unsorted is 12. [] SORTED LIST

29 Selection sort UNSORTED LIST [17, 93, 12, 44, 82, 81, 22, 73] Remove 12 from unsorted. [] SORTED LIST

30 Selection sort UNSORTED LIST [17, 93, 44, 82, 81, 22, 73] Add 12 to end of sorted. [12] SORTED LIST

31 Selection sort UNSORTED LIST [17, 93, 44, 82, 81, 22, 73] Smallest from unsorted is 17. [12] SORTED LIST

32 Selection sort UNSORTED LIST [ 93, 44, 82, 81, 22, 73] Remove 17 from unsorted. [12] SORTED LIST

33 Selection sort UNSORTED LIST [93, 44, 82, 81, 22, 73] Add 17 to end of sorted. [12, 17] SORTED LIST

34 Selection sort UNSORTED LIST [93, 44, 82, 81, 22, 73] Smallest from unsorted is 22. [12, 17] SORTED LIST

35 Selection sort UNSORTED LIST [93, 44, 82, 81, 73] Remove 22 from unsorted. [12, 17] SORTED LIST

36 Selection sort UNSORTED LIST [93, 44, 82, 81, 73] Add 22 to end of sorted. [12, 17, 22] SORTED LIST

37 Selection sort UNSORTED LIST [93, 44, 82, 81, 73] Smallest from unsorted is 44. [12, 17, 22] SORTED LIST

38 Selection sort UNSORTED LIST [93, 82, 81, 73] Remove 44 from unsorted. [12, 17, 22] SORTED LIST

39 Selection sort UNSORTED LIST [93, 82, 81, 73] Add 44 to end of sorted. [12, 17, 22, 44] SORTED LIST

40 Selection sort UNSORTED LIST [93, 82, 81, 73] Smallest from unsorted is 73. [12, 17, 22, 44] SORTED LIST

41 Selection sort UNSORTED LIST [93, 82, 81 ] Remove 73 from unsorted. [12, 17, 22, 44] SORTED LIST

42 Selection sort UNSORTED LIST [93, 82, 81] Add 73 to end of sorted. [12, 17, 22, 44, 73] SORTED LIST

43 Selection sort UNSORTED LIST [93, 82, 81] Smallest from unsorted is 81. [12, 17, 22, 44, 73] SORTED LIST

44 Selection sort UNSORTED LIST [93, 82 ] Remove 81 from unsorted. [12, 17, 22, 44, 73] SORTED LIST

45 Selection sort UNSORTED LIST [93, 82] Add 81 to end of sorted. [12, 17, 22, 44, 73, 81] SORTED LIST

46 Selection sort UNSORTED LIST [93, 82] Smallest from unsorted is 82. [12, 17, 22, 44, 73, 81] SORTED LIST

47 Selection sort UNSORTED LIST [93 ] Remove 82 from unsorted. [12, 17, 22, 44, 73, 81] SORTED LIST

48 Selection sort UNSORTED LIST [93] Add 82 to end of sorted. [12, 17, 22, 44, 73, 81, 82] SORTED LIST

49 Selection sort UNSORTED LIST [93] Smallest from unsorted is 93. [12, 17, 22, 44, 73, 81, 82] SORTED LIST

50 Selection sort UNSORTED LIST [ ] Remove 93 from unsorted. [12, 17, 22, 44, 73, 81, 82] SORTED LIST

51 Selection sort UNSORTED LIST [] Add 93 to end of sorted. [12, 17, 22, 44, 73, 81, 82, 93] SORTED LIST

52 Selection sort UNSORTED LIST [] Since the unsorted list is empty, we're done! [12, 17, 22, 44, 73, 81, 82, 93] SORTED LIST

53 Selection sort def removesmallest(x): smallestindex = 0 for Y in range(1,len(x)): if X[Y] < X[smallestIndex]: smallestindex = Y return X.pop(smallestIndex) def selectionsort(x): sorted = [] while len(x) > 0: sorted.push(removesmallest(x)) return sorted

54 Merge sort Given a list of values, split into in left and right partitions of roughly equal size. Sort each partition, then merge the two sorted partitions.

55 Merge sort basic idea [17, 93, 12, 44, 82, 81, 22, 73]

56 Merge sort split into partitions [17, 93, 12, 44, 82, 81, 22, 73] [17, 93, 12, 44][82, 81, 22, 73]

57 Merge sort sort partitions [17, 93, 12, 44, 82, 81, 22, 73] [17, 93, 12, 44][82, 81, 22, 73]... [12, 17, 44, 93][22, 73, 81, 82]

58 Merge sort merge partitions [17, 93, 12, 44, 82, 81, 22, 73] [17, 93, 12, 44][82, 81, 22, 73]... [12, 17, 44, 93][22, 73, 81, 82] [12, 17, 22, 44, 73, 81, 82, 93]

59 Merge sort merge partitions [17, 93, 12, 44, 82, 81, 22, 73] [17, 93, 12, 44][82, 81, 22, 73] [17, 93][12, 44][82, 81][22, 73] [17][93][12][44][82][81][22][73] [17, 93][12, 44][81, 82][22, 73] [12, 17, 44, 93][22, 73, 81, 82] [12, 17, 22, 44, 73, 81, 82, 93]

60 Merge sort def merge(x, L, M, R): temp = [] lp = L rp = M while lp < M and rp < R: if X[lp] < X[rp]: temp.append(x[lp]) lp = lp + 1 else: temp.append(x[rp]) rp = rp + 1 while lp < M: temp.append(x[lp]) lp = lp + 1 while rp < R: temp.append(x[rp]) rp = rp + 1 for i in range(l,r): X[i] = temp[i-l] def mergesorthelper(x, Left, Right): if Right - Left > 1 : Mid = (Left + Right) // 2 mergesorthelper(x, Left, Mid) mergesorthelper(x, Mid, Right) merge(x, Left, Mid, Right) def mergesort(x) : mergesorthelper(x, 0, len(x)) return X

61 Selection vs Merge sort # comparisons are a good measure of work If input has N items: A complete sort requires roughly N 2 x<y comparisons. N 2 grows quickly: (2N) 2 = 4 N 2 Double input size quadruples work needed. If input has N items: A complete sort requires roughly N*log2(N) x<y comparisons. N*log2(N) grows slowly: (2N)*log2(2N) = 2N*(log2(2)+log2(N)) = 2N*(1+log2(N)) Double input size a little more than doubles work needed.

62 For next time: Draw graphs (by hand) of N 2 and N*log2(N) over range 100 to 100,000.