This preview shows page 1. Sign up to view the full content.
Unformatted text preview: DATA STRUCTURES SORTING
Mergesort
Mergesort Why Does It Matter?
Why
Run time
(nanoseconds) 47 N log2N 48 N 1.3 seconds 10 msec 0.4 msec 0.048 msec 10,000 22 minutes 1 second 6 msec 0.48 msec 100,000 15 days 1.7 minutes 78 msec 4.8 msec million 41 years 2.8 hours 0.94 seconds 48 msec 10 million
Max size
problem
solved
in one 10 N2 1000
Time to
solve a
problem
of size 1.3 N3 41 millennia 1.7 weeks 11 seconds 0.48 seconds second 920 10,000 1 million 21 million minute 3,600 77,000 49 million 1.3 billion hour 14,000 600,000 2.4 trillion 76 trillion day 41,000 2.9 million 50 trillion 1,800 trillion 1,000 100 10+ 10 N multiplied by 10,
time multiplied by Orders of Magnitude
Orders
Seconds Equivalent
1 1 second 10 10 seconds 102 1.7 minutes 103 17 minutes 104 2.8 hours 105 1.1 days 106 1.6 weeks 107 3.8 months 108 3.1 years 109 3.1 decades 1010 3.1 centuries ... forever 1021 age of
universe Meters Per
Second Imperial
Units Example 1010 1.2 in / decade Continental drift 108 1 ft / year Hair growing 106 3.4 in / day Glacier 104 1.2 ft / hour Gastrointestinal tract 102 2 ft / minute Ant 1 2.2 mi / hour Human walk 102 220 mi / hour Propeller airplane 104 370 mi / min Space shuttle 106 620 mi / sec Earth in galactic orbit 108 62,000 mi / sec 1/3 speed of light Powers
of 2 210 thousand 220 million 230 billion Impact of Better Algorithms
Impact
Example 1: Nbodysimulation.
Simulate gravitational interactions among N bodies.
physicists want N = # atoms in universe Brute force method: N2 steps.
Appel (1981). N log N steps, enables new research.
Appel Example 2: Discrete Fourier Transform (DFT).
Breaks down waveforms (sound) into periodic components.
foundation of signal processing
CD players, JPEG, analyzing astronomical data, etc. Grade school method: N2 steps.
RungeKönig (1924), CooleyTukey (1965).
FFT algorithm: N log N steps, enables new technology. Mergesort
Mergesort
Mergesort (divideandconquer)
Divide array into two halves. A
A L
L G
G O
O R
R I T
I H
T M
H S
M S divide Mergesort
Mergesort
Mergesort (divideandconquer)
Divide array into two halves.
Recursively sort each half. A L G O R I T H M S A L G O R I T H M S divide A G L O R H I M S T sort Mergesort
Mergesort
Mergesort (divideandconquer)
Divide array into two halves.
Recursively sort each half.
Merge two halves to make sorted whole. A L G O R I T H M S A L G O R I T H M S divide A G L O R H I M S T sort A G H I L M O R S T merge Merging
Merging
Merge.
Keep track of smallest element in each sorted half.
Insert smallest of two elements into auxiliary array.
Repeat until done. smallest A G
A smallest L O R H I M S T
auxiliary array Merging
Merging
Merge.
Keep track of smallest element in each sorted half.
Insert smallest of two elements into auxiliary array.
Repeat until done. smallest A G
A L
G smallest O R H I M S T
auxiliary array Merging
Merging
Merge.
Keep track of smallest element in each sorted half.
Insert smallest of two elements into auxiliary array.
Repeat until done. smallest A G
A L
G O
H smallest R H I M S T
auxiliary array Merging
Merging
Merge.
Keep track of smallest element in each sorted half.
Insert smallest of two elements into auxiliary array.
Repeat until done. smallest A G
A L
G smallest O
H R
I H I M S T
auxiliary array Merging
Merging
Merge.
Keep track of smallest element in each sorted half.
Insert smallest of two elements into auxiliary array.
Repeat until done. smallest A G
A L
G smallest O
H R
I H
L I M S T
auxiliary array Merging
Merging
Merge.
Keep track of smallest element in each sorted half.
Insert smallest of two elements into auxiliary array.
Repeat until done. smallest A G
A L
G O
H smallest R
I H
L M I M S T
auxiliary array Merging
Merging
Merge.
Keep track of smallest element in each sorted half.
Insert smallest of two elements into auxiliary array.
Repeat until done. smallest A G
A L
G O
H smallest R
I H
L M I
O M S T
auxiliary array Merging
Merging
Merge.
Keep track of smallest element in each sorted half.
Insert smallest of two elements into auxiliary array.
Repeat until done. smallest A G
A L
G O
H smallest R
I H
L M I
O M
R S T
auxiliary array Merging
Merging
Merge.
Keep track of smallest element in each sorted half.
Insert smallest of two elements into auxiliary array.
Repeat until done.
first half
exhausted A G
A L
G O
H R
I smallest H
L M I
O M
R S
S T
auxiliary array Merging
Merging
Merge.
Keep track of smallest element in each sorted half.
Insert smallest of two elements into auxiliary array.
Repeat until done.
first half
exhausted A G
A L
G O
H R
I smallest H
L M I
O M
R S
S T
T auxiliary array Implementing Mergesort
Implementing
mergesort (see Sedgewick Program 8.3)
Item aux[MAXN]; uses scratch array void mergesort(Item a, int left, int right) {
int mid = (right + left) / 2;
if (right <= left)
return;
mergesort(a, left, mid);
mergesort(a, mid + 1, right);
merge(a, left, mid, right);
} Implementing Merge (Idea 0)
Implementing
mergeAB(Item c, Item a, int N, Item b, int M )
{ int i, j, k;
int
for (i = 0, j = 0, k = 0; k < N+M; k++)
for
{
if (i == N) { c[k] = b[j++]; continue; }
if
if (j == M) { c[k] = a[i++]; continue; }
if
c[k] = (less(a[i], b[j])) ? a[i++] : b[j++];
c[k]
}
} Implementing Mergesort
Implementing
merge (see Sedgewick Program 8.2)
void merge(Item a, int left, int mid, int right) {
int i, j, k;
for (i = mid+1; i > left; i)
aux[i1] = a[i1];
for (j = mid; j < right; j++)
aux[right+midj] = a[j+1];
for (k = left; k <= right; k++)
if (ITEMless(aux[i], aux[j]))
a[k] = aux[i++];
else
a[k] = aux[j];
} copy to
temporary array merge two sorted
sequences Mergesort Demo
Mergesort
Mergesort The auxilliary array used in the merging
Mergesort
operation is shown to the right of the array a, going
from (N+1, 1) to (2N, 2N).
The demo is a dynamic representation of the algorithm
in action, sorting an array a containing a permutation of
the integers 1 through N. For each i, the array element
a[i] is depicted as a black dot plotted at position (i, a[i]).
Thus, the end result of each sort is a diagonal of black
dots going from (1, 1) at the bottom left to (N, N) at the
top right. Each time an element is moved, a green dot is
left at its old position. Thus the moving black dots give a
dynamic representation of the progress of the sort and
the green dots give a history of the datamovement cost. ...
View
Full
Document
 Summer '11
 RAJIVSIR
 Sort

Click to edit the document details