Design Patterns for Sorting Teaching something old in a new light
-
Upload
acton-collins -
Category
Documents
-
view
34 -
download
2
description
Transcript of Design Patterns for Sorting Teaching something old in a new light
![Page 1: Design Patterns for Sorting Teaching something old in a new light](https://reader035.fdocuments.in/reader035/viewer/2022062719/56813298550346895d9930f4/html5/thumbnails/1.jpg)
Design Patterns for SortingTeaching something old in a
new light
Dung “Zung” Nguyen Stephen Wong
Rice University
![Page 2: Design Patterns for Sorting Teaching something old in a new light](https://reader035.fdocuments.in/reader035/viewer/2022062719/56813298550346895d9930f4/html5/thumbnails/2.jpg)
Thanks!Computer Science
by Stan Warford, Pepperdine University
![Page 3: Design Patterns for Sorting Teaching something old in a new light](https://reader035.fdocuments.in/reader035/viewer/2022062719/56813298550346895d9930f4/html5/thumbnails/3.jpg)
What is Sorting Anyway?
Can We Abstract All Sorting Processes?
Some concrete examples: Selection sort Insertion sort
![Page 4: Design Patterns for Sorting Teaching something old in a new light](https://reader035.fdocuments.in/reader035/viewer/2022062719/56813298550346895d9930f4/html5/thumbnails/4.jpg)
Merritt’s Thesis for Sorting All comparison-based sorting can be viewed as
“Divide and Conquer” algorithms. Sort a pile
Split the pile into smaller piles Sort each the smaller piles Join the sorted smaller piles into sorted pile
![Page 5: Design Patterns for Sorting Teaching something old in a new light](https://reader035.fdocuments.in/reader035/viewer/2022062719/56813298550346895d9930f4/html5/thumbnails/5.jpg)
Unsorted
Sorted
split
split
split
split
join
join
joinjoin
split
join
= unsorted = sorted = sort process
Hypothetical Sort
Divide and Conquer!
How can we capture this abstraction?
![Page 6: Design Patterns for Sorting Teaching something old in a new light](https://reader035.fdocuments.in/reader035/viewer/2022062719/56813298550346895d9930f4/html5/thumbnails/6.jpg)
Abstract Sorter Class
ASorter
+ void: sort(Object[ ] A, int: lo, int: hi);
# int: split(Object[] A, int lo, int hi);
# void: join(Object[] A, int lo, int s, int hi);
if (lo < hi) { int s = split (A, lo, hi); sort (A, lo, s-1); sort (A, s, hi); join (A, lo, s, hi);}
Concrete“Template Method”
SortAlgoSelection Insertion
abstract,relegated to subclasses
![Page 7: Design Patterns for Sorting Teaching something old in a new light](https://reader035.fdocuments.in/reader035/viewer/2022062719/56813298550346895d9930f4/html5/thumbnails/7.jpg)
Template Method PatternAClass
+ invariant(…);# variant1(…);# variant2(…);
invariant () { … variant1 (…); … variant2 (…); …}
ConcreteX
# variant1(…);# variant2(…);
ConcreteY
# variant1(…);# variant2(…);
Expresses invariant in terms of variants.
White-box Framework: Extension by subclassing
![Page 8: Design Patterns for Sorting Teaching something old in a new light](https://reader035.fdocuments.in/reader035/viewer/2022062719/56813298550346895d9930f4/html5/thumbnails/8.jpg)
Sort Frameworkvoid sort (Object A[ ], int lo, int hi) {
if (lo < hi) { int s = split (A, lo, hi);
sort (A, lo, s-1);
sort (A, s, hi);
join (A, lo, s, hi);
} }
// A[lo:s-1], A[s:hi] form a proper partition of A[lo:hi].
// A[lo:s-1] is sorted.
// A[s:hi] is sorted.
// A[lo:hi] is sorted.
Recursive case
“Free”
Focus points
Base case is trivial
// else if (hi <= lo) do nothing!
![Page 9: Design Patterns for Sorting Teaching something old in a new light](https://reader035.fdocuments.in/reader035/viewer/2022062719/56813298550346895d9930f4/html5/thumbnails/9.jpg)
Insertion Sort int split(Object[] A, int lo, int hi) {
• return hi;// A splits into A[lo:hi-1] and A[hi:hi]}
void join(Object[] A, int lo, int s, int hi) {
// Pre: A[lo:hi-1] is sorted, s = hi.
• Object key = A[hi];int j;for (j = hi; lo < j && aOrder.lt(key, A[j-1]); j- -) A[j] = A[j-1];A[j] = key;// Post: A[hi] is inserted in order into A[lo:hi-1]}
Reduces to insertion of a single object into a sorted array.
Simplifies proof of correctness.
![Page 10: Design Patterns for Sorting Teaching something old in a new light](https://reader035.fdocuments.in/reader035/viewer/2022062719/56813298550346895d9930f4/html5/thumbnails/10.jpg)
Selection Sort
int split(Object[] A, int lo, int hi) {• int s = lo;
for (int i= lo+1; i <= hi; I++) { if (aOrder.lt(A[i], A[s])) s = i;}
// s = index of min value• swap (A, lo, s);
// A[lo] = min value in A[lo:hi]• return lo + 1;
// A splits into A[lo:lo] and A[lo+1:hi]}
void join(Object[] A, int lo, int s, int hi) { }
Reduces to selecting a minimum value in the array.
Simplifies proof of correctness
Do Nothing!
![Page 11: Design Patterns for Sorting Teaching something old in a new light](https://reader035.fdocuments.in/reader035/viewer/2022062719/56813298550346895d9930f4/html5/thumbnails/11.jpg)
Time Complexity
void sort (Object A[ ], int l, int h) { if (l < h) {
• int s = split (A, l, h);• sort (A, l, s-1);• sort (A, s, h);• join (A, l, s, h);}}
T(l, h) C
S(l, h)T(l, s-1)T(s, h)J(l, s, h)
T(l, h) = C if h <= l C + S(l, h) + T(l, s-1) + T(s, h) + J(l, s, h) if l < h
![Page 12: Design Patterns for Sorting Teaching something old in a new light](https://reader035.fdocuments.in/reader035/viewer/2022062719/56813298550346895d9930f4/html5/thumbnails/12.jpg)
T(l, h) = C if h <= l C + S(l, h) + T(l, s-1) + T(s, h) + J(l, s, h) if l < h
s = h
T(l, h) =• C if h <= l• C + S(l, h) + T(l, h-1) + T(h, h) + J(l, h, h) if l < h
Insertion Sort Complexity int split (Object[ ] A, int l, int h) {
return h;} // O(1)
void join (Object[ ] A, int l, int s, int h) { Object key = A[h]; int j; for (j = h; l < j && aOrder.lt(key, A[j-1]); j- -) A[j] = A[j-1]; A[j] = key;} // O(h-l)
O(n), n = h - l
O(1)
Let n = h – l, T(l, h) = T(n) =• C if n < 1• T(n-1) + O(n) = O(n2) if 1 <= n
![Page 13: Design Patterns for Sorting Teaching something old in a new light](https://reader035.fdocuments.in/reader035/viewer/2022062719/56813298550346895d9930f4/html5/thumbnails/13.jpg)
Sorting as a Framework
Unifies sorting under one foundational principle:Divide and Conquer!
Reduces code complexity. Increases robustness. Simplifies program verification and complexity analysis.
ASorter
+ void: sort(Object[ ] A, int: lo, int: hi);
# int: split(Object[] A, int lo, int hi);
# void: join(Object[] A, int lo, int s, int hi);
if (lo < hi) { int s = split (A, lo, hi); sort (A, lo, s-1); sort (A, s, hi); join (A, lo, s, hi);}
![Page 14: Design Patterns for Sorting Teaching something old in a new light](https://reader035.fdocuments.in/reader035/viewer/2022062719/56813298550346895d9930f4/html5/thumbnails/14.jpg)
MergeInsertion
Classifications
HeapSortSelection QuickSort Bubble
ASorter+ void: sort(Object[] a, int: lo, int: hi);# int: split(Object[] A, int lo, int hi);# void: join(Object[] A, int lo, int s, int hi);
Easy split/Hard join
Hard split/Easy join
![Page 15: Design Patterns for Sorting Teaching something old in a new light](https://reader035.fdocuments.in/reader035/viewer/2022062719/56813298550346895d9930f4/html5/thumbnails/15.jpg)
Not Just Buzzwords… Reusability: write once/use many
Reuse the invariant: the framework Flexibility: change the variants
Add new sorters Change sort order
Extensibility: add new capabilities Visualization Performance measurements
It’s more than just sorting…It’s all about abstraction…
![Page 16: Design Patterns for Sorting Teaching something old in a new light](https://reader035.fdocuments.in/reader035/viewer/2022062719/56813298550346895d9930f4/html5/thumbnails/16.jpg)
Extending Without Changing Graphics, sort order and performance
measurements are completely separate from the sorting.
Add functionality to the sorters, ordering operators, and sortable objects without disturbing their abstract behavior.
Wrap the sorters, operators and objects in something abstractly equivalent that adds functionality: Decorators
The Abstract is the Invariant
![Page 17: Design Patterns for Sorting Teaching something old in a new light](https://reader035.fdocuments.in/reader035/viewer/2022062719/56813298550346895d9930f4/html5/thumbnails/17.jpg)
Decorator performs additional processingDecorators can be layered on top of each other
Decorator Design Pattern
AComponent + Object: method(Object x)
ConcreteImpl + Object: method(Object x)
Subclass holds an instance of its superclass
Decorator is abstractly equivalent to the decoree
Clientuses
Client doesn’t know the decoration exists!
Decorator intercepts calls to decoree
Client deals with an abstract entity
1
Decorator
+ Object: method(Object x)
- AComponent: decoree
// do additional processingObject y = decoree.method(x);// do more processingreturn y;
![Page 18: Design Patterns for Sorting Teaching something old in a new light](https://reader035.fdocuments.in/reader035/viewer/2022062719/56813298550346895d9930f4/html5/thumbnails/18.jpg)
SortersAbstract TemplatePatternsorter
Sort using anabstract ordering
strategy
Concrete sorters implement
split() & join()
DecoratedASorter
for graphicalsplit & join
Abstract objectsbeing sorted“Decoratable”!
ASorter uses the ordering strategy for comparisons
“Decoratable”!
![Page 19: Design Patterns for Sorting Teaching something old in a new light](https://reader035.fdocuments.in/reader035/viewer/2022062719/56813298550346895d9930f4/html5/thumbnails/19.jpg)
GraphicSorter Decorator
private ASorter sorter;
int split(Object[] A, int lo, int hi) {
int s = sorter.split(A, lo, hi);
// recolor split sections and pause
return s;
}
void join(Object[] A, int lo, int s, int hi) {
sorter.join(A, lo, s, hi);
// recolor joined sections and pause
}
Decoree.
Delegation tothe decoree.
Graphicsdecoration.
Delegation tothe decoree.
Graphicsdecoration.
Identical behavioras the decoree.
![Page 20: Design Patterns for Sorting Teaching something old in a new light](https://reader035.fdocuments.in/reader035/viewer/2022062719/56813298550346895d9930f4/html5/thumbnails/20.jpg)
Abstract comparison
operator
DecoratedAOrderto count
comparisons
DecoratedAOrder
to graphicallyshow
comparisons
DecoratedAOrder
to reversesort order
Comparison Strategies
![Page 21: Design Patterns for Sorting Teaching something old in a new light](https://reader035.fdocuments.in/reader035/viewer/2022062719/56813298550346895d9930f4/html5/thumbnails/21.jpg)
Sortable Integers
Concreteimplementation
Abstract class
Decorated AIntegerto countaccesses
IColoredObject adapter + AInteger decorator
for graphics
Factorymethod
forcomparison
strategy
![Page 22: Design Patterns for Sorting Teaching something old in a new light](https://reader035.fdocuments.in/reader035/viewer/2022062719/56813298550346895d9930f4/html5/thumbnails/22.jpg)
Teaching beyond sorting…
Abstraction unifies and simplifiesInstead of disparate and complex
Abstraction enables flexibility and extensibilityInstead of rigidity and limitedness
Design Patterns Express Abstraction
Change the way the students think!
![Page 23: Design Patterns for Sorting Teaching something old in a new light](https://reader035.fdocuments.in/reader035/viewer/2022062719/56813298550346895d9930f4/html5/thumbnails/23.jpg)
Download the paper!
http://www.exciton.cs.rice.edu/research/SIGCSE01