Class 16- Insertion Sort

7/30/2019 Class 16- Insertion Sort

1/20

Data Structures

&Algorithms

Prof. Ravi Prakash Gorthi

Aug-Dec, 2010


2/20

Data Structures & Algorithms

Topics

Why Study DS & Algorithms?

Abstract Data Types

Arrays and Linked Lists

Stacks & Queues

Trees & Graphs

Sorting and Searching

Complexity of Algorithms


3/20

Bubbling All the Elements

77123542 51 2 3 4 5 6

101

5421235 771 2 3 4 5 6

101

4253512 771 2 3 4 5 6

101

4235512 771 2 3 4 5 6

101

4235125 771 2 3 4 5 6

101Number

ofIteration

sis(N1

)1

2

34

5

# of comparisons is

on an average N/2


4/20

Bubble Sort AlgorithmSorted-List[] := Bubble-Sort (USL[], N);/ USL*1:N+ contains the N Unsorted Integers /

{ int J := N 1; boolean did-swap := true;

while ((J > 0) AND (did-swap)) do/* this while loop performs (N-1) iterations */

{did-swap := false;

for (K = 1 to J) do/* this for loop bubbles-up the next largest integer into the (J1) position

progressively*/{

if (USL[K] > USL[K + 1])then { Swap (USL[K], USL[K + 1]);

did-swap := true;}

}J := J 1;}

return (USL[]);

}

In the worst-case,the number of

iterations is (N-1)!


comparisons is N/2!




5/20

Bubble Sort AlgorithmSorted-List[] := Bubble-Sort (USL[], N);/ USL*1:N+ contains the N Unsorted Integers /

{ int J := N 1; boolean did-swap := true;

while ((J > 0) AND (did-swap)) do/* this while loop performs (N-1) iterations */

{did-swap := false;

for (K = 1 to J) do/* this for loop bubbles-up the next largest integer into the (J1) position

progressively*/{

if (USL[K] > USL[K + 1])then { Swap (USL[K], USL[K + 1]);

did-swap := true;}

}J := J 1;}

return (USL[]);

}

In thebest-case,the number of

iterations is 1!

In the best-case,the number of

comparisons is N!

In the best-case, thenumber of comparisons

is (N-1)!


6/20

Complexity of Bubble Sort AlgorithmIn the worst-case, this algorithm performs (N 1) iterations and

on an average (N/2) comparisons in each iteration;

that is, (N 1) * (N/2).

Worst-case Complexity is O (n2).

In the Best-case, when the given list is already sorted, this

algorithm makes N comparisons; i.e. complexity is O (n).

Assume that there are 1million integers and each comparison

takes 1 micro-second.

This sort algorithm takes ((10) ** (12)) * ( (10) ** (-6)) seconds,

which is (10**(6)) seconds or approximately 278 hours or 11

days.


7/20

Insertion Sort


8/20

Example: sorting numbered cards

23 17 45 18 12 22

1 2 6543

1 2 6543


9/20


23

17 45 18 12 22

1 2 6543

1 2 6543


10/20


2317

45 18 12 22

1 2 6543

1 2 6543


11/20


2317 45

18 12 22

1 2 6543

1 2 6543


12/20


2317 45

18 12 22

1 2 6543

1 2 6543


13/20


2317 4518

12 22

1 2 6543

1 2 6543


14/20


2317 4518

12 22

1 2 6543

1 2 6543


15/20


2317 451812

22

1 2 6543

1 2 6543


16/20


2317 451812

22

1 2 6543

1 2 6543


17/20


1812 2217 23 45

1 2 6543

1 2 6543


18/20

Insertion SortSorted-List[] := Insertion-Sort (USL[], N);

{ USL[1:N] is the unsorted list of integers */int array Temp-SL[1:N]; int I, J, K;

Temp-SL[1] := USL[1];

for (I = 2 to N) do{/* insert element USL[I] into Temp-SL[] */

Temp-SL [] := Insert-element (USL[I], Temp-SL[], I);

}

return (Temp-SL[]);

}




19/20

Insertion Sort (Contd.)Temp-SL[] := Insert-element (element, Temp-SL[], I);

{/* insert element into the right position in Temp-SL[] */boolean did-insert := false;

int J := I 1;

while ((!did-insert) && (J != 0)) do

{ if (element > Temp-Sl[J]

then { Temp-SL[J + 1] := element;

did-insert := true;

}

else Temp-SL [J + 1] := Temp-SL [J];

J := J 1;}

if (!did-insert) then Temp-SL [1] := element;

return (Temp-SL[]);

}


comparisons is N/2!

In the best-case,the number of

comparisons is 1!


20/20

Complexity of Insertion Sort AlgorithmIn the worst-case, this algorithm performs (N 1) iterations and

on an average (N/2) comparisons in each iteration;that is, (N 1) * (N/2).

Worst-case Complexity is O (n2).

In the Best-case, when the given list is already sorted, this

algorithm makes N comparisons; i.e. complexity is O (n).

Class 16- Insertion Sort

Documents

Transcript of Class 16- Insertion Sort