1. Remember Sorting_Machine? Isn’t it a beauty! Go ahead... kick the tires! Change_To_ Extraction_Phase InOut

2. Sorting_Machine Continued… Change_To_ Extraction_Phase InOut 3: Sorted items come out here 2: Push the button 1: Items go in here

3. Sorting_Machine Continued… Type ( inserting: boolean contents: multiset of Item ) Initial value (true, {})

4. A Math Type: Multiset Multisets are just like sets except that duplicates are allowed In set theory: {2, 18, 2, 36} = {2, 18, 36} and |{2, 18, 2, 36}| = 3 In multiset theory: {2, 18, 2, 36} /= {2, 18, 36} and |{2, 18, 2, 36}| = 4

5. Sorting_Machine Continued… Operations m.Insert (x) m.Change_To_Extraction_Phase ( ) m.Remove_First (x) m.Remove_Any (x) m.Is_In_Extraction_Phase ( ) m.Size ( )

6. Sorting With Sorting_Machine // input a bunch of integers placing them in sorting machine m while (not ins.At_EOS ()) { object Integer i; ins >> i; m.Insert (i); } // now output the same integers in sorted order m.Change_To_Extraction_Phase (); while (m.Size () > 0) { object Integer i; m.Remove_First (i); outs << i << ‘\n’; }

7. Sorting Algorithms Selection Sort Insertion Sort Mergesort Quicksort Heapsort Tree Sort …

8. A Sort Procedure procedure Sort ( alters Queue_Of_Item& q ); /*! ensures q is permutation of #q and IS_ORDERED (q) !*/

9. Math Definition math definition IS_ORDERED ( s: string of Item ): boolean is for all u, v: Item where ( * is substring of s) (ARE_IN_ORDER (u, v))

10. An Old Math Definition math definition ARE_IN_ORDER ( x: Item, y: Item ): boolean satisfies restriction for all x, y, z: Item (ARE_IN_ORDER (x, x) and (ARE_IN_ORDER (x, y) or ARE_IN_ORDER (y, x)) and (if (ARE_IN_ORDER (x, y) and ARE_IN_ORDER (y, z)) then ARE_IN_ORDER (x, z)))

11. Selection Sort procedure Remove_Min ( alters Queue_Of_Item& q, produces Item& x ); /*! requires q /= empty_string ensures (q * ) is permutation of #q and for all y: Item where (y is in elements (q)) (ARE_IN_ORDER (x, y)) !*/

12. Selection Sort: You Give It A Try procedure Sort ( alters Queue_Of_Item& q ) { } object Queue_Of_Item tmp; while (q.Length () > 0) { object Item x; Remove_Min (q, x); tmp.Enqueue (x); } q &= tmp;

13. Insertion Sort procedure Insert_In_Order ( alters Queue_Of_Item& q, consumes Item& x ); /*! requires IS_ORDERED (q) ensures q is permutation of (#q * ) and IS_ORDERED (q) !*/

14. Insertion Sort: You Give It A Try procedure Sort ( alters Queue_Of_Item& q ) { } object Queue_Of_Item tmp; while (q.Length () > 0) { object Item x; q.Dequeue (x); Insert_In_Order (tmp, x); } q &= tmp;

15. Quicksort procedure Partition ( consumes Queue_Of_Item& q, preserves Item& p, produces Queue_Of_Item& q1, produces Queue_Of_Item& q2 ); /*! ensures q1 * q2 is permutation of #q and for all x: Item where (x is in elements (q1)) (ARE_IN_ORDER (x, p)) and for all x: Item where (x is in elements (q2)) (not ARE_IN_ORDER (x, p)) !*/

16. Quicksort Continued… procedure Combine ( produces Queue_Of_Item& q, consumes Item& p, consumes Queue_Of_Item& q1, consumes Queue_Of_Item& q2 ); /*! ensures q = #q1 * * #q2 !*/

17. Quicksort: You Give It A Try procedure Sort ( alters Queue_Of_Item& q ) { } if (q.Length () > 1) { object Item x; object Queue_Of_Item q1, q2; q.Dequeue (x); Partition (q, x, q1, q2); Sort (q1); Sort (q2); Combine (q, x, q1, q2); }

18. Quicksort Continued… procedure Partition ( consumes Queue_Of_Item& q, preserves Item& p, produces Queue_Of_Item& q1, produces Queue_Of_Item& q2 ) { } q1.Clear (); q2.Clear (); while (q.Length () > 0) { object Item x; q.Dequeue (x); if (Item_Are_In_Order::Are_In_Order (x, p)) { q1.Enqueue (x); } else { q2.Enqueue (x); } }

19. Quicksort Continued… procedure Combine ( produces Queue_Of_Item& q, consumes Item& p, consumes Queue_Of_Item& q1, consumes Queue_Of_Item& q2 ) { } q.Clear (); q &= q1; q.Enqueue (p); while (q2.Length () > 0) { object Item x; q2.Dequeue (x); q.Enqueue (x); }

20. Mergesort procedure Split ( consumes Queue_Of_Item& q, produces Queue_Of_Item& q1, produces Queue_Of_Item& q2 ); /*! ensures q1 * q2 is permutation of #q and |q2| <= |q1| <= |q2| + 1 !*/

21. Mergesort Continued… procedure Merge ( consumes Queue_Of_Item& q1, consumes Queue_Of_Item& q2, produces Queue_Of_Item& q ); /*! requires IS_ORDERED (q1) and IS_ORDERED (q2) ensures q is permutation of #q1 * #q2 and IS_ORDERED (q) !*/

22. Mergesort: You Give It A Try procedure Sort ( alters Queue_Of_Item& q ) { } if (q.Length () > 1) { object Queue_Of_Item q1, q2; Split (q, q1, q2); Sort (q1); Sort (q2); Merge (q1, q2, q); }

23. Sorting_Machine: Inside Story Are you ready to look under the hood of this baby? Change_To_ Extraction_Phase InOut

24. Inside Story Continued… As an example, assume the representation for Sorting_Machine has two fields: contents_rep of type Queue_Of_Item inserting_rep of type Boolean What are some possible implementations?

25. Let’s Procrastinate — the Students’ Choice operation m.Insert (x) m.Change_To_ Extraction_Phase () m.Remove_First (x) m.Remove_Any (x) what happens? q.Enqueue (x) set phase to extraction Remove_Min (q, x) q.Dequeue (x) c1c1 c2c2 c3nc3n c4c4 How long will it take to perform each operation as a function of n = |m.contents|? cn 2 c1nc1n c3n2c3n2

26. How About Eager Beavers operation m.Insert (x) m.Change_To_ Extraction_Phase () m.Remove_First (x) m.Remove_Any (x) what happens? Insert_In_Order (q, x) set phase to extraction q.Dequeue (x) c1nc1n c2c2 c3c3 c3c3 How long will it take to perform each operation as a function of n = |m.contents|? cn 2 c1n2c1n2 c3nc3n

27. Are There Other Possibilities? operation m.Insert (x) m.Change_To_ Extraction_Phase () m.Remove_First (x) m.Remove_Any (x) what happens? q.Enqueue (x) q.Sort () set phase to extraction q.Dequeue (x) c1c1 c 2 nlogn c3c3 c3c3 How long will it take to perform each operation as a function of n = |m.contents|? cnlogn c1nc1n c3nc3n

28. A Heapsort Implementation An ARE_IN_ORDER Heap is a special kind of binary tree: shape property: the tree is complete ordering property: for each item x in the tree, ARE_IN_ORDER (x, child) holds for each child of x

29. Complete Binary Trees All levels of the tree are completely filled up except possibly the bottom level. Any “holes” in the bottom level must appear to the right of all existing items at that level.

30. Heap Ordering Property For each item x in the tree: x yz ARE_IN_ORDER (x, y) and ARE_IN_ORDER (x, z) x y ARE_IN_ORDER (x, y)

31. Examples 18 3624 585361 18 3624 5312 18 3624 536158 14 2112 Item is Integer ARE_IN_ORDER (x, y)  x  y 18 36 5338 14 21

32. Heapsort Build an ARE_IN_ORDER heap with the items to be sorted using the specified ARE_IN_ORDER Implement Remove_First so that, after removing the first item in the ordering from the heap, it restores the heap properties

33. How Will Remove_First Work? 12 4618 547337 8263 99 4618 547337 8263 99 1263 4618 547337 82 99 18 4663 547337 82 99 18 4637 547363 82 99

34. Sift _Root _Down procedure Sift_Root_Down ( alters “binary tree” t ); /*! requires [t is a complete tree and both left and right subtrees of t are heaps] ensures [t is a heap and t contains exactly the items in #t] !*/

35. Turning a Complete Tree Into a Heap procedure Heapify ( alters “binary tree” t ); /*! requires [t is a complete tree] ensures [t is a heap and t contains exactly the items in #t] !*/ Hint:

36. Turning a Complete Tree Into a Heap Continued… procedure_body Heapify ( alters “binary tree” t ) { } if (|t| > 1) { Heapify (left subtree of t) Heapify (right subtree of t) Sift _Root_Down (t) }

37. Mapping Complete Binary Tree Positions Into Array Locations 12 4618 547337 8263 99 Let’s number the tree positions (top-bottom, left-right) (1) (2)(3) (4)(5)(6)(7) (9)(8) Which array corresponds to the tree? 1 23456789 124618547337998263 x yz (i) (2i)(2i+1)

38. Remember Array Operations? a.Set_Bounds (lower, upper) a[i] --accessor operation a.Lower_Bound () a.Upper_Bound ()

39. Insertion-Phase Container? What is the effect of a.Set_Bounds (lower, upper)? At what point will the Sorting_Machine be ready to set the array bounds?

40. Swapping/Comparing Two Elements in an Array Given: object Array_Of_Item a; object Integer i, j; What’s wrong with: a[i] &= a[j] and Item_Are_In_Order::Are_In_Order (a[i], a[j])? They violate the repeated argument rule a[i] and a[j] are references to parts of a’s representation: the parts could be the same (see Partial_Map_Kernel_3)

41. Swapping Two Array Elements Use a.Exchange_At (i, j) instead of a[i] &= a[j] Exchange_At is an Array extension It requires that a.lb  i, j  a.ub See AT/Array/Exchange_At.h in the RESOLVE_Catalog for complete specs

42. Comparing Two Array Elements Use a.Are_In_Order_At (i, j) instead of Item_Are_In_Order::Are_In_Order (a[i], a[j]) Are_In_Order_At is an Array extension It requires that a.lb  i, j  a.ub See AT/Array/Are_In_Order_At.h in the RESOLVE_Catalog for complete specs

43. Sorting_Machine_Kernel_2: Component Coupling Diagram Sorting_Machine_ Type ext i Sorting_Machine_ Kernel Sorting_Machine_ Kernel_2 RepresentationArray_Kernel u u enc i i i Queue_KernelArray_ Exchange_At Array_ Are_In_Order_At General_ Are_In_Order iu i i