Remember Sorting_Machine?

1 / 43

# Remember Sorting_Machine? - PowerPoint PPT Presentation

## Remember Sorting_Machine?

- - - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - - -
##### Presentation Transcript

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

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

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 (<u> * <v> is substring of s) (ARE_IN_ORDER (u, v))

10. An Old Math Definition math definition ARE_IN_ORDER ( x: Item, y: Item ): boolean satisfiesrestriction 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 * <x>) 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 * <#x>) 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 * <#p> * #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. Change_To_ Extraction_Phase In Out Sorting_Machine: Inside Story Are you ready to look under the hood of this baby?

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. operation m.Insert (x) m.Change_To_ Extraction_Phase () m.Remove_First (x) m.Remove_Any (x) what happens? cn2 Let’s Procrastinate — the Students’ Choice c1 q.Enqueue (x) c1n c2 set phase to extraction c3n Remove_Min (q, x) c3n2 c4 q.Dequeue (x) How long will it take to perform each operation as a function of n = |m.contents|?

26. operation m.Insert (x) m.Change_To_ Extraction_Phase () m.Remove_First (x) m.Remove_Any (x) what happens? cn2 How About Eager Beavers c1n Insert_In_Order (q, x) c1n2 c2 set phase to extraction c3 q.Dequeue (x) c3n c3 q.Dequeue (x) How long will it take to perform each operation as a function of n = |m.contents|?

27. operation m.Insert (x) m.Change_To_ Extraction_Phase () m.Remove_First (x) m.Remove_Any (x) what happens? cnlogn Are There Other Possibilities? c1 q.Enqueue (x) c1n q.Sort () set phase to extraction c2nlogn c3 q.Dequeue (x) c3n c3 q.Dequeue (x) How long will it take to perform each operation as a function of n = |m.contents|?

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. x x y z y Heap Ordering Property • For each item x in the tree: ARE_IN_ORDER (x, y) and ARE_IN_ORDER (x, z) ARE_IN_ORDER (x, y)

31. Examples 14 18 18 14 21 36 36 24 21 12 18 53 38 53 12 18 36 24 36 24 53 61 58 Item is Integer ARE_IN_ORDER (x, y)  x  y 53 61 58

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. 63 12 12 46 18 46 18 46 18 54 73 37 99 54 73 37 18 99 54 73 37 99 18 82 82 63 82 63 46 63 46 37 54 73 37 99 54 73 63 99 82 82 How Will Remove_First Work?

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. Hint: 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] !*/

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. x y z Which array corresponds to the tree? Mapping Complete Binary TreePositions Into Array Locations Let’s number the tree positions (top-bottom, left-right) (1) 12 (2) 46 (3) 18 (i) (4) 54 (5) 73 (6) 37 (7) 99 (2i) (2i+1) (8) 82 (9) 63 12 46 18 54 73 37 99 82 63 2 3 4 5 6 7 8 9 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 ofa.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 ofa[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_ Type Representation Queue_Kernel Array_Kernel Array_ Are_In_Order_At Sorting_Machine_ Kernel General_ Are_In_Order Sorting_Machine_ Kernel_2 Array_ Exchange_At Sorting_Machine_Kernel_2: Component Coupling Diagram ext i i u enc i u u i i i i