1. Selection sort
・In iteration i, find index min of smallest remaining entry.
・Swap a[i] and a[min].

i min 0 1 2 3 4 5 6 7 8 9 10
S O R T E X A M P L E
0 6 S O R T E X A M P L E
1 4 A O R T E X S M P L E
2 10 A E R T O X S M P L E
3 9 A E E T O X S M P L R
4 7 A E E L O X S M P T R
5 7 A E E L M X S O P T R
6 8 A E E L M O S X P T R
7 10 A E E L M O P X S T R
8 8 A E E L M O P R S T X
9 9 A E E L M O P R S T X
10 10 A E E L M O P R S T X
A E E L M O P R S T X

2. Insertion sort
・In iteration i, swap a[i] with each larger entry to its left.

i j 0 1 2 3 4 5 6 7 8 9 10
S O R T E X A M P L E
1 0 O S R T E X A M P L E
2 1 O R S T E X A M P L E
3 3 O R S T E X A M P L E
4 0 E O R S T X A M P L E
5 5 E O R S T X A M P L E
6 0 A E O R S T X M P L E
7 2 A E M O R S T X P L E
8 4 A E M O P R S T X L E
9 2 A E L M O P R S T X E
10 2 A E E L M O P R S T X
A E E L M O P R S T X

3. Mergesort (top-down)
Given two sorted subarrays a[lo] to a[mid] and a[mid+1] to a[hi], replace with sorted subarray a[lo] to a[hi].

0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
M E R G E S O R T E X A M P L E
merge(a, aux, 0, 0, 1) E M R G E S O R T E X A M P L E
merge(a, aux, 2, 2, 3) E M G R E S O R T E X A M P L E
merge(a, aux, 0, 1, 3) E G M R E S O R T E X A M P L E
merge(a, aux, 4, 4, 5) E G M R E S O R T E X A M P L E
merge(a, aux, 6, 6, 7) E G M R E S O R T E X A M P L E
merge(a, aux, 4, 5, 7) E G M R E O R S T E X A M P L E
merge(a, aux, 0, 3, 7) E E G M O R R S T E X A M P L E
merge(a, aux, 8, 8, 9) E E G M O R R S E T X A M P L E
merge(a, aux, 10, 10, 11) E E G M O R R S E T A X M P L E
merge(a, aux, 8, 9, 11) E E G M O R R S A E T X M P L E
merge(a, aux, 12, 12, 13) E E G M O R R S A E T X M P L E
merge(a, aux, 14, 14, 15) E E G M O R R S A E T X M P E L
merge(a, aux, 12, 13, 15) E E G M O R R S A E T X E L M P
merge(a, aux, 8, 11, 15) E E G M O R R S A E E L M P T X
merge(a, aux, 0, 7, 15) A E E E E G L M M O P R R S T X

4. Quicksort (standard, no shuffle)
Repeat until i and j pointers cross.
・Scan i from left to right so long as (a[i] < a[lo]).
・Scan j from right to left so long as (a[j] > a[lo]).
・Exchange a[i] with a[j].
When pointers cross.
・Exchange a[lo] with a[j].

lo j hi 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
Q U I C K S O R T E X A M P L E - initial values
K R A T E L E P U I M Q C X O S - random shuffle
0 5 15 E C A I E K L P U T M Q R X O S
0 3 4 E C A E I K L P U T M Q R X O S
0 2 2 A C E E I K L P U T M Q R X O S
0 0 1 A C E E I K L P U T M Q R X O S
1 1 A C E E I K L P U T M Q R X O S
4 4 A C E E I K L P U T M Q R X O S
6 6 15 A C E E I K L P U T M Q R X O S
7 9 15 A C E E I K L M O P T Q R X U S
7 7 8 A C E E I K L M O P T Q R X U S
8 8 A C E E I K L M O P T Q R X U S
10 13 15 A C E E I K L M O P S Q R T U X
10 12 12 A C E E I K L M O P R Q S T U X
10 11 11 A C E E I K L M O P Q R S T U X
10 10 A C E E I K L M O P Q R S T U X
14 14 15 A C E E I K L M O P Q R S T U X
15 15 A C E E I K L M O P Q R S T U X
A C E E I K L M O P Q R S T U X

5. Heapsort
Basic plan for in-place sort.
・Create max-heap with all N keys.
Heap construction. Build max heap using bottom-up method.
・Repeatedly remove the maximum key.
Sortdown. Repeatedly delete the largest remaining item.