Transcript Slide 1

An Algorithm for:
Explaining Algorithms
Tomasz Müldner
September 12
1
Vision = what is where by looking
Visualization = the power or
process of forming a mental image
of vision of something not actually
present to the sight
You have 10s to find this image
September 12
2
Dijkstra feared…
“…permanent mental damage for most
students exposed to program visualization
software …”
September 12
3
Contents
•
•
•
•
•
•
Preface
Introduction to Algorithm Visualization, AV
Examples of AV
Algorithm Explanation, AE
Examples of AE
Conclusions & Future Work
September 12
4
Preface
•
Under Construction
• Early version
• Invitation to collaborate
September 12
5
Al-Khorezmi -> Algorithm
The ninth century:
• the chief mathematician in the academy of
sciences in Baghdad
September 12
6
Introduction to AV
AV uses multimedia:
– Graphics
– Animation
– Auralization
to show abstractions of data
September 12
7
Examples of AV
•
•
•
•
Multiple Sorting
Duke
More
AIA
September 12
8
Typical Approach in AV
• take the description of the algorithm
• graphically represent data in the code using
bars, points, etc.
• use animation to represent the flow of
control
• show the animated algorithm and hope that
the learner will now understand the
algorithm
September 12
9
Problems with AV
•
•
•
•
Graphical language versus text
Low level of abstraction (code stepping)
Emphasis on meta-tools
Students perform best if they are asked to
develop visualizations
• no attempt to visualize or even suggest
essential properties, such as invariants
• Very few attempts to visualize recursive
algorithms
September 12
10
Introduction to AE
• systematic procedure to explain algorithms:
an algorithm for explaining algorithms
• Based on findings from Cognitive
Psychology, Constructivism Theory,
Software Engineering
• visual representation is used to help reason
about the textual representation
• Use multiple abstraction levels to focus on
selected issues
• Designed by experts
September 12
11
Goals of AE
•
•
•
•
September 12
Understanding of both, what the algorithm
is doing and how it works
Ability to justify the algorithm correctness
(why the algorithm works)
Ability to code the algorithm in any
programming language
Understanding of time complexity of the
algorithm
12
Requirements for AE
•
•
•
•
September 12
The algorithm is presented at several
levels of abstraction
Each level of abstraction is represented by
the abstract data model and pseudocode
The design supports active learning
The design helps to understand time
complexity
13
Levels of Abstraction
public static void selection(List aList) {
for (int i = 0; i < aList.size(); ++i)
swap(smallest(i, aList) , i, aList);
}
Primitive operations can be:
• Explained at different abstraction level
• inlined
September 12
14
AE Catalogue Entries
•
•
•
•
September 12
Multi-leveled Abstract Algorithm Model
Example of an abstract implementation of
the Abstract Algorithm Model
Tools that can be used to help to predict
the algorithm complexity
Questions for students
15
MAK
• Uses multimedia:
– Graphics
– Animation
– Auralization
to show abstractions of data
• Interacts with the student; e.g. by providing
post-tests
• Uses a student model for adaptive behavior
September 12
16
MAK
Selection Sort
Insertion Sort
Quick Sort
September 12
17
Selection Sort: Abstract Data Model
Sequences of elements of type T, denoted by Seq<T>
with a linear order defined in one of three ways:
•
type T supports the function
int compare(const T x)
•
type T supports the “<” relation
•
there is a global function
int comparator(const T x, const T y)
September 12
18
Selection Sort: Top level of Abstraction
Abstract Data Model
Type T also supports the function
swap(T el1, T el2)
The following operations on Seq<T> are available:
•
a sequence t can be divided into prefix and suffix
• the prefix can be incremented (which will decrement
the suffix)
• first(suffix)
September 12
• T smallest(seq<T> t, Comparator comp)
19
Selection Sort: Top level of Abstraction
Pseudocode
void selection(Seq<T> t, Comparator comp) {
for(prefix = NULL; prefix != t; increment prefix by one element)
swap( smallest(suffix, comp), first(suffix) );
}
September 12
20
Visualization
void selection(Seq<T> t, Comparator comp) {
for(prefix = NULL; prefix != t; increment prefix by one element)
swap( smallest(suffix, comp), first(suffix) );
}
List two invariants
September 12
21
void selection(Seq<T> t, Comparator comp) {
for(prefix = NULL; prefix != t; increment prefix by one element)
swap( smallest(suffix, comp), first(suffix) );
}
List two invariants
September 12
22
Selection Sort: Low level of Abstraction
Pseudocode
T smallest(Seq<T> t, Comparator comp) {
smallest = first element of t;
for(traverse t forward)
if(smallest & current are out of order)
smallest = current;
}
September 12
23
Visualization
September 12
T smallest(Seq<T> t, Comparator comp) {
smallest = first element of t;
for(traverse t forward)
if(smallest & current out of order)
smallest = current;
}
24
Abstract Implementation
The Abstract Iterator Implementation Model
assumes
• There is an Iterator type, where iterations are
performed over a half-closed interval [a, b)
• Iterator type supports the following operations:
– two iterators can be compared for equality and
inequality
– there are operations to provide various kinds of
traversals; for example forward and backward
– an iterator can be dereferenced to access the object it
points to
September 12
25
Abstract Implementation
The Abstract Iterator Implementation Model assumes (Cont.):
• The domain Seq<T> supports
Seq<T>::Iterator
• The following two operations are defined
on sequences:
– Iterator t.begin()
– Iterator t.end()
September 12
26
Selection Sort: Abstract Implementation
Pseudocode
September 12
void selection(Seq<T> t, Comparator comp) {
Seq<T>::Iterator eop; // end of prefix
for(eop = t.begin(); eop != t.end(); ++eop)
swap(smallest(eop, t.end(), comp), eop);
}
T smallest(Seq<T> t, Comparator comp) {
Iterator small = t.begin();
Iterator current;
for(current = t.begin(); current != t.end(); ++current)
if(value of current < value of small) small = current;
return value of small;
27
}
void selection(T *x, T* const end, int comparator(const T, const T)) {
T* eop;
for(eop = x; eop != end; ++eop)
swap( smallest(eop, end, comparator), eop );
}
T *smallest(T * const first, T * const last, int comparator(const T, const T) ) {
T *small = first;
T *current;
for(current = first; current != last; ++ current)
if(comparator(* current, *small) < 0) small = current;
return s;
}
void selection(Seq<T> t, Comparator comp) {
Seq<T>::Iterator eop; // end of prefix
for(eop = t.begin(); eop != t.end(); ++eop)
swap(smallest(eop, t.end(), comp), eop);
C implementation
September 12
}
T smallest(Seq<T> t, Comparator comp) {
Iterator small = t.begin();
Iterator current;
for(current = t.begin(); current != t.end(); ++current)
if(value of current < value of small) small = current;
28
return value of small;
}
typedef struct {
int a;
int b;
} T;
#define SIZE(x) (sizeof(x)/sizeof(T))
T x[ ] = { {1, 2}, {3, 7}, {2, 4}, {11, 22} };
#define S SIZE(x)
int comparator1(const T x, const T y) {
if(x.a == y.a) return 0;
if(x.a < y.a) return -1;
return 1;
}
int comparator2(const T x, const T y) {
if(x.a == y.a)
if(x.b = y.b) return 0;
else if(x.b < y.b) return -1;
else return 1;
if(x.a < y.a) return -1;
return 1;
}
September 12
int main() {
printf("original sequence\n");
show(x, S);
selection(x, x+S, comparator1);
printf("sequence after first sort\n");
show(x, S);
selection(x, x+S, comparator2);
printf("sequence after second sort\n");
show(x, S);
}
29
template <typename Iterator, typename Predicate>
void selection(Iterator first, Iterator last, Predicate compare) {
Iterator eop;
for(eop = first; eop != last; ++eop)
swap(*min_element(eop, last, compare), *eop);
}
void selection(Seq<T> t, Comparator comp) {
Seq<T>::Iterator eop; // end of prefix
for(eop = t.begin(); eop != t.end(); ++eop)
swap(smallest(eop, t.end(), comp), eop);
C++
implementation
September 12
}
T smallest(Seq<T> t, Comparator comp) {
Iterator small = t.begin();
Iterator current;
for(current = t.begin(); current != t.end(); ++current)
if(value of current < value of small) small = current;
30
return value of small;
}
public static void selection(List aList, Comparator aComparator) {
for (int i = 0; i < aList.size(); i++)
swap(smallest(i, aList, aComparator) , i, aList);
}
private static int smallest(int from, List aList, Comparator aComp) {
int minPos = from;
int count = from;
for (ListIterator i = aList.listIterator(from); i.hasNext(); ++count)
if (aComp.compare(i.next(), aList.get(minPos)) < 0)
minPos = count;
return minPos;
void selection(Seq<T> t, Comparator comp) {
Seq<T>::Iterator eop; // end of prefix
}
for(eop = t.begin(); eop != t.end(); ++eop)
swap(smallest(eop, t.end(), comp), eop);
Java
implementation
September 12
}
T smallest(Seq<T> t, Comparator comp) {
Iterator small = t.begin();
Iterator current;
for(current = t.begin(); current != t.end(); ++current)
if(value of current < value of small) small = current;
31
return value of small;
}
Algorithm Complexity
Three kinds of tools:
• to experiment with various data sizes and
plot a function that approximates the time
spent on execution with this data.
• a visualization that helps to carry out time
analysis of the algorithm
• questions regarding the time complexity
September 12
32
Post Test
1. What is the number of comparisons and swaps performed when
selection sort is executed for:
1. sorted sequence
2. sequence sorted in reverse
2. What is the time complexity of the function isSorted(t), which checks
if t is a sorted sequence?
3. Hand-execute the algorithm for a sample set of input data of size 4.
4. Hand-execute the next step of the algorithm for the specified state
5. What’s the last step of the algorithm?
6. There are two invariants of this algorithm; which one is essential for
the correctness of swap(smallest(), eop), and why.
7. “do it yourself “
September 12
33
Quick Sort
Pseudocode
void quick(Seq<T> t, Comparator comp) {
if( size(t) <= 1) return;
pivot = choosePivot(t);
divide(pivot, t, t1, t2, t3, comp);
quick(t1, comp);
quick(t3, comp);
concatenate(t, t1, t2, t3);
}
September 12
34
September 12
35
September 12
36
September 12
37
Future Work
•
•
•
•
•
•
•
evaluation (eye movement?)
student model
different visualizations
more complex algorithms
Algorithmic design patterns
generic approach
MAK
September 12
38