This course covers the essential information that every serious programmer needs to know about algorithms and data structures, with emphasis on applications and scientific performance analysis of Java implementations. Part I covers elementary data structures, sorting, and searching algorithms. Part II focuses on graph- and string-processing algorithms.
Shellsort
Loading...
En provenance du cours de Princeton University
Algorithms, Part I
3801 notes
À partir de la leçon
Elementary Sorts
We introduce the sorting problem and Java's Comparable interface. We study two elementary sorting methods (selection sort and insertion sort) and a variation of one of them (shellsort). We also consider two algorithms for uniformly shuffling an array. We conclude with an application of sorting to computing the convex hull via the Graham scan algorithm.
Rencontrer les enseignants
Kevin WayneSenior Lecturer
Computer Science
Robert SedgewickWilliam O. Baker *39 Professor of Computer Science
Computer Science
Now, we'll look at Shellsort which is a bit elementary on the face of it but it's
not at all elementary as you'll see. The idea of Shellsort is that Insertion Sort
is inefficient because elements really move only one position at the time even
when we're kind of know that they have a long way to go. The idea behind Shellsort
is that we'll move entries several positions at a time and the way we're
going to do it, it's called h-sorting the array. So, an h-sorted array is h
different inter leaves sorted sub-sequences so in this case with h=4
if we start at L and look at every fourth element - M, P, T - then it's sorted. If
we start in the second place at E and look at every fourth element, it's sorted. So
this is 4 interleave sequences, that's a 4-sorted array. And what we're going
to do is implement a sorting method that h-sort for decreasing sequences of values
of h. This is one of the oldest sorting methods invented by Shell in 1959. So, in
this case, it starts out with the input example shown and then the 13-sort -
a few items are moved, 4-sort - a few more are moved, and then finally, a 1-sort.
And the idea is that each of the sorts can be implemented with only a few
exchanges given that the previous ones happened. So first thing is how do we get an
array h-sorted? That's actually pretty easy. We just use Insertion Sort but
instead of going one back every time we come with a new item, we go h back. So for
example when we come to this A in the Insertion Sort, then it's, we look at the
array before that and then there was M and E in the positions three back so we
exchange the A with the larger one to its left, that's M and then the other larger
one to its left, that's E and then put it into position. So the code is the same as
insertion, as for Insertion Sort, except that when we go backwards through the
array we skip by h instead of just by one. That's how we h-sort an array. And the
idea is we're going to use Insertion Sort because of two reasons based on our
understanding of how Insertion Sort works. While the first thing is if the increments
are big then the size of the sub arrays that we're sorting are pretty small so any
sorting method including Insertion Sort is going to work well. But the other thing is
if the increments are small because we've done previous h-sorts for bigger
values of h, the array is partially sorted and so Insertions Sort is going to be
fast. You wouldn't work to use Shellsort as the basis for h-sorting because that
always takes quadratic time no matter what order there is in the array. So let's look
at example of Shellsort with increment 7, 3, and 1. So, we start with
this sort example and then 7-sorting it - just involves doing insertion
sort but just reaching back 7 each time. In this case, the 4
subfiles stretched out at seven each only have two elements in them. And then we
3-sort. Now, because it's 7-sorted and a 3-sort elements are either
already in placed or on a go back a few strides. On this case, it's only the A
that goes back two. And then we 1-sort and again because of the fact that it's
been 7-sorted and 3-sorted, the arrays are almost in order when it comes
time to do the 1-sort and most of the items only go back one or two positions.
So we have to do a few extra passes to do the higher sorts but the each element
moves only a little bit on each path and that's how Shellsort gains its efficiency.
So actually once you 1-sort, that's Insertion Sort so you're going to always
get a sorted result. The only difference is how efficient is that. Now the
intuition behind Shellsort and actually the mathematical fact is that if you've
got an array that's h-sorted and then you k-sort it for another value k different
from h, it's still h-sorted. This is one of those mathematical facts that seems
obvious but then if you try to prove that maybe it's a little more subtle than you
think. So, if you think of all this is, is, is trivial and easy, go ahead and try
to write down a proof that a g-sorted array remains g-sorted even after it's
h-sorted. But most people will accept that and it's a fact and that's how Shellsort
gains efficiency. Now there's another problem is what increment sequence should
we use for Shellsort. One of the first things you might think of is let's try
powers of two. Actually that one doesn't work at all, very well at all because it
winds up not comparing elements in even positions with elements in the odd
positions until the 1-sort which means performance can be bad. Shell's original
idea is to try powers to two minus one and that works okay. Knuth when he wrote his
books in the 60s proposed the increment sequence 3x + 1. We'll start with the
1, 4, 13, 40, 121, 364 like that and that's good because it's
easy to compute. When we're using in Shellsort of course, we find the largest
increment less than our file size and then do the sorts for decreasing values of that
increment. But finding the best increment sequence is a research problem that has
confounded people for quite a long time. Here's an increment sequence that I found
after maybe a year's work and it works well but nobody knows if that's the best
one. So here's the implementation in Java of Shellsort for Knuth's 3x + 1
increment sequence. We'll just go ahead and compute the increments that are
less than n, n / 3 and then starting at that increment whatever it is and say,
we started 364 then next time we need an increment, we'll just divide it by 3,
364 integer divide by 3, 364 integer / 3 it gets 121, 40 and so forth. So,
this h = h / 3 gets us to the next increment. And then, the implementation is
just Insertion Sort. We just go through starting at h for i and when we do the
insertion, the j loop, we decrement j by h each time, otherwise the code is exactly
like Insertion Sort. So, just adding this extra loop for h-sorting and this extra
loop to compute the increments to Insertion Sort, we get a slightly more
complicated piece of code but its much, much more efficient. Here's what it looks
like for a bigger array. We start with the randomly ordered input and you can see
that it gets more and more in order on each time that we h-sort for the
decreasing values of h. Here's an animation. This animation does the whole
h-sort for each subarray. It's a little better feeling for what's going on.
And now to do the high ones pretty quickly and now it's doing the 1-sort and again
it steps through the array pretty quickly. If it's partially sorted it doesn't make
much difference - does the higher sorts a little bit faster. But that's simple to
implement and very efficient sorting algorithm. Now, the analysis of Shellsort
is still open. Now, there's a few things that we can say. For example we can say
that the number of comparison and the worst case is O(N3/2) for the 3x + 1
increments. But actually in practice it's much less than that. The problem is nobody
knows an accurate model for describing the number of compares taken by Shellsort
for any interesting increment sequence. This seems to be with a small value,
multiple of n times the number of increments used which is some multiple maybe of n log n
but nobody is been able to find an accurate model that proves that for any
interesting increment sequence for Shellsort. So, why we are interested in
this algorithm? Well, it's a simple idea that leads to substantial performance
gains. It's very useful in practice because it's pretty fast except for very
huge arrays. It's going to beat even the classical sophisticated methods for medium
sized arrays. And it doesn't take much code. It's often used in embedded systems
or in hardware sort type systems because there's so little code involved to
implement it. And it just leads to a lot of interesting questions. This gets to the
intellectual challenge of developing algorithms. If you think what we've been
studying so far is trivial, go ahead and find a better increment sequence. Try some
technique to discover one and try to say something about the average-case
performance of Shellsort. People have been trying to do that for 50 years without a
whole lot of success. So, the lesson is that we can develop good algorithms or
good implementations without much code but there are some out there that are still
waiting discovery. It could be that there are some increment sequence out there that
make Shellsort more efficient than any other method, any of the sorting method
that we know for pratical file size, no one can deny that. That's Shellsort or
first non-trivial sorting method.
Explorer notre catalogue
Rejoignez-nous gratuitement et obtenez des recommendations, des mises à jour et des offres personnalisées.
Coursera propose un accès universel à la meilleure formation au monde,
en partenariat avec des universités et des organisations du plus haut niveau, pour proposer des cours en ligne.
© 2018 Coursera Inc. Tous droits réservés.
