1. Insertion and Shell Sorts

2. Learning Objective Review the Bubble, and Selection sorts
Be able to describe the speed, stability and how a Insertion sort works
Be able to describe the speed, stability and how a Shell sort works
Write a program that uses the Shell or Insertion Sort.

3. Review Show after the third pass of the Bubble Sort Low High
Show after the third pass of the Selection Sort

4. Insertion Sort Can you describe how it works? Animation

5. Insertion Sort Details
Speed
Stability
How it works
Your turn
Low High

6. Procedure insertion(var theArray:theArrayType; size:integer);
dummy:integer;
pass, check:integer;
Begin
for pass:= 2 to size do
begin
dummy:= theArray[pass];
check := pass-1;
while (theArray[check]>dummy) and (check>=1) do
theArray[check+1] := theArray[check];
check:=check-1;
end;
theArray[check+1] := dummy;
End;

7. Shellsort
Founded by Donald Shell and named the sorting algorithm after himself in 1959.
1st algorithm to break the quadratic time barrier O(n^2) but few years later, a sub quadratic time bound was proven
Shellsort works by comparing elements that are distant rather than adjacent elements in an array or list where adjacent elements are compared.

8. Shellsort
How it works
Uniquely grouped insertion sort.

9. Shellsort Shellsort is also known as diminishing increment sort.
The distance between comparisons decreases as the sorting algorithm runs until the last phase in which adjacent elements are compared

10. Empirical Analysis of Shellsort (Advantage)
Advantage of Shellsort is that its only efficient for medium size lists. For bigger lists, the algorithm is not the best choice.
Speed: Different sources with different speeds.
O(N1.25)
5 times faster than the bubble sort and a little over twice as fast as the insertion sort, its closest competitor.
Not Stable

11. Empirical Analysis of Shellsort (Disadvantage)
Disadvantage of Shellsort is that it is a complex algorithm and its not nearly as efficient as the merge, heap, and quick sorts.
The shell sort is still significantly slower than the merge, heap, and quick sorts, but its relatively simple algorithm makes it a good choice for sorting lists of less than 5000 items unless speed important. It's also an excellent choice for repetitive sorting of smaller lists.

12. Shellsort Best Case
Best Case: The best case in the shell sort is when the array is already sorted in the right order. The number of comparisons is less.

13. Shellsort Example
Sort:

14. Shell Sort Summary Speed: O(n^1.25) Stability: Not Stable
How it works: A uniquely grouped insertion sort.

15. procedure shellSort(var numbers:ArrayType; size:integer);
pass, check, increment, dummy : integer;
begin
increment := size DIV 2;
while (increment > 0) do
for pass:= 2 to size do //Insertion Sort
check := pass;
dummy := numbers[pass]; //Dummy
while ((check >= increment) AND (numbers[check-increment] > dummy))do
numbers[check] := numbers[check - increment]; //Slide
check := check - increment;
end;
numbers[check] := dummy; // Back
if (increment div 2 <> 0) then
increment := increment div 2
else if (increment = 1) then
increment := 0
else
increment := 1;
end; //Shell sort procedure
Shell Sort Code

16. Shell Sort Program Options
Complete one of the program options. Either Shell or Insertion.
Sorting Names
Input: 10 names
Show the names after they are sorted using the Shell Sort.
Push: Handle names entered with DiFfErEnT CaSeS.
Sorting Numbers
Input: 8 Numbers
Show the numbers after each pass of the Shell sort.
Push: Color coordinate the numbers to show which are being compared.
Extension:
Create your own sorting algorithm. Possibly combine the best of the algorithms discussed in class.

17. Insertion Sort Program Options
Complete one of the program options. Either Shell or Insertion.
Sort Race
Randomly generate integers (from 1-100)
Time how long it takes the insertion sort to put the values in order.
Push: Time sorting the same values with all of the sorts and rate their speed.
Name, height (in inches) Sort
Input: 10 names and heights
Output: The names and corresponding heights in a chart sorted by age using an Insertion sort.
Push: Let the user decide if they want to sort by height or name, then sort and show the chart.
Push: Input an unknown number of names and heights to sort.