Chapter 7 sorting a lgorithms
Download
1 / 11

Chapter 7: Sorting A lgorithms - PowerPoint PPT Presentation


  • 165 Views
  • Updated On :

Mark Allen Weiss: Data Structures and Algorithm Analysis in Java. Chapter 7: Sorting A lgorithms. Shell Sort. Lydia Sinapova, Simpson College. Shell Sort. Improves on insertion sort Compares elements far apart , then less far apart , finally compares adjacent elements

loader
I am the owner, or an agent authorized to act on behalf of the owner, of the copyrighted work described.
capcha
Download Presentation

PowerPoint Slideshow about 'Chapter 7: Sorting A lgorithms' - kennita


An Image/Link below is provided (as is) to download presentation

Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.


- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -
Presentation Transcript
Chapter 7 sorting a lgorithms l.jpg

Mark Allen Weiss: Data Structures and Algorithm Analysis in Java

Chapter 7: Sorting Algorithms

Shell Sort

Lydia Sinapova, Simpson College


Shell sort l.jpg
Shell Sort Java

  • Improves on insertion sort

  • Compares elementsfar apart, thenless far apart, finally comparesadjacentelements

    (as an insertion sort).


Slide3 l.jpg
Idea Java

  • arrange the data sequence in atwo-dimensional array

  • sort the columnsof the array

  • repeatthe process each time withsmaller number of columns


Example l.jpg
Example Java

3 7 9 0 5 1 6 8 4 2 0 6 1 5 7 3 4 9 8 2

it is arranged in an array with 7 columns (left),

then the columns are sorted (right):

3 7 9 0 5 1 6 3 3 2 0 5 1 5

8 4 2 0 6 1 5  7 4 4 0 6 1 6

7 3 4 9 8 2 8 7 9 9 8 2


Example cont l.jpg
Example (cont) Java

3 3 2 0 0 1

0 5 1 1 2 2

5 7 4 3 3 4

4 0 6 4 5 6

1 6 8 5 6 8

7 9 9 7 7 9

8 2 8 9

one column in the last step –

it is only a 6, an 8 and a 9 that have to move a little bit to their correct position


Implementation l.jpg
Implementation Java

  • one-dimensional array that is

  • indexed appropriately.

  • an increment sequence

  • to determine how far apart elements to be sorted are


Increment sequence l.jpg
Increment sequence Java

Determines how far apart elements to be sorted are:

h1, h2, ..., ht with h1 = 1

hk-sorted array - all elements spaced a distance hkapart are sorted relative to each other.


Correctness of the algorithm l.jpg
Correctness of the algorithm Java

Shellsort only works because an array that is hk-sorted remains hk-sorted when hk- 1-sorted.

Subsequent sorts do not undo the work done by previous phases.

The last step (with h = 1) -

Insertion Sort on the whole array


Java code for shell sort l.jpg
Java code for Shell sort Java

int j, p, gap; comparable tmp;

for (gap = N/2; gap > 0; gap = gap/2)

for ( p = gap; p < N ; p++)

{

tmp = a[p];

for ( j = p ; j >= gap && tmp < a[ j- gap ];

j = j - gap)

a[ j ] = a[ j - gap ];

  a[j] = tmp;

}


Increment sequences l.jpg
Increment sequences Java

1. Shell's original sequence:

N/2 , N/4 , ..., 1 (repeatedly divide by 2).

2. Hibbard's increments:

1, 3, 7, ..., 2k - 1 ;

3. Knuth's increments:

1, 4, 13, ..., ( 3k - 1) / 2 ;

4. Sedgewick's increments:

1, 5, 19, 41, 109, ....

9 ·4k - 9 ·2k + 1 or 4k - 3 ·2k + 1.


Analysis l.jpg
Analysis Java

Shellsort's worst-case performance using Hibbard's increments is Θ(n3/2).

 The averageperformance is thought to be about O(n 5/4)

The exact complexity of this algorithm is still being debated .

for mid-sized data : nearly as well if not better than the faster (n log n) sorts.


ad