Data Structures & Algorithms
Prof. Ravi Prakash Gorthi Aug-Dec, 2010
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
Bubbling All the Elements
2 1 3 4 5
# of comparisons is on an average N/2
Number of Iterations is (N 1)
1 42 1 35 1 12 1 12 1 5
2 35 2 12 2 35 2 5 2 12
3 12 3 42 3 5 3 35 3 35
4 77 4 5 4 42 4 42 4 42
5 5 5 77 5 77 5 77 5 77
6 101 6 101 6 101 6 101 6 101
Bubble Sort Algorithm
Sorted-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;
In the worst-case, the number of iterations is (N-1)!
for (K = 1 to J) do /* this for loop bubbles-up the next largest integer into the (J+1) position progressively*/ { if (USL[K] > USL[K + 1]) then { Swap (USL[K], USL[K + 1]); did-swap := true; In the worst-case, } the number of } comparisons is N/2! J := J 1; } return (USL[]); }
Bubble Sort Algorithm
Sorted-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;
In the best-case, the number of iterations is 1!
for (K = 1 to J) do /* this for loop bubbles-up the next largest integer into the (J+1) position progressively*/ { if (USL[K] > USL[K + 1]) then { Swap (USL[K], USL[K + 1]); did-swap := true; In the best-case, the } the number number of comparisons of } comparisons is (N-1)! is N! J := J 1; } return (USL[]); }
Complexity of Bubble Sort Algorithm
In 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.
Insertion Sort
Example: sorting numbered cards
23
1
17
2
45
3
18
4
12
5
22
6
Example: sorting numbered cards
17
1 2
45
3
18
4
12
5
22
6
23
1 2
Example: sorting numbered cards
45
1 2 3
18
4
12
5
22
6
17
1
23
2
Example: sorting numbered cards
18
1 2 3 4
12
5
22
6
17
1
23
2
45
3 4
5 6
Example: sorting numbered cards
18
1 2 3 4
12
5
22
6
17
1
23
2
45
3 4
5 6
Example: sorting numbered cards
12
1 2 3 4 5
22
6
17
1
18
2
23
3
45
4
5 6
Example: sorting numbered cards
12
1 2 3 4 5
22
6
17
1
18
2
23
3
45
4
5 6
Example: sorting numbered cards
22
1 2 3 4 5 6
12
1
17
2
18
3
23
4
45
5 6
Example: sorting numbered cards
22
1 2 3 4 5 6
12
1
17
2
18
3
23
4
45
5 6
Example: sorting numbered cards
12
1
17
2
18
3
22
4
23
5
45
6
Insertion Sort
Sorted-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[] */
In the worst-case, the number of iterations is (N-1)!
Temp-SL [] := Insert-element (USL[I], Temp-SL[], I); } return (Temp-SL[]); }
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[]); }
In the worst-case, the number of comparisons is N/2!
In the best-case, the number of comparisons is 1!
Complexity of Insertion Sort Algorithm
In 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).
