CS 162 Intro to Programming II Sor1ng I 1 Sor1ng - - PowerPoint PPT Presentation

CS ¡162 ¡ Intro ¡to ¡Programming ¡II ¡

Sor1ng ¡I ¡

1 ¡

Sor1ng ¡

• A ¡sor1ng ¡algorithms ¡rearranges ¡the ¡elements ¡

so ¡that ¡they ¡are ¡in ¡ascending ¡or ¡descending ¡

• rder ¡
• Many ¡algorithms ¡are ¡similar ¡to ¡how ¡we ¡would ¡

sort ¡a ¡pile ¡of ¡papers ¡ ¡

• Every ¡item ¡must ¡be ¡compared ¡at ¡least ¡once ¡
• Our ¡goal ¡is ¡to ¡minimize ¡the ¡number ¡of ¡
• pera1ons-­‑ ¡as ¡efficiently ¡as ¡possible ¡

2 ¡

Selec1on ¡Sort ¡

• Find ¡the ¡smallest ¡element ¡of ¡the ¡unsorted ¡

region ¡ ¡

• Swap ¡the ¡smallest ¡element ¡with ¡the ¡first ¡item ¡
• f ¡the ¡unsorted ¡region ¡ ¡

3 ¡

4 ¡ 42 ¡ 15 ¡ 8 ¡ 16 ¡ 23 ¡ 23 ¡ 42 ¡ 15 ¡ 8 ¡ 16 ¡ 4 ¡

Selec1on ¡Sort ¡ ¡

4 ¡ 42 ¡ 15 ¡ 8 ¡ 16 ¡ 23 ¡ 23 ¡ 42 ¡ 15 ¡ 8 ¡ 16 ¡ 4 ¡ 23 ¡ 42 ¡ 15 ¡ 16 ¡ 8 ¡ 4 ¡ 23 ¡ 42 ¡ 16 ¡ 15 ¡ 8 ¡ 4 ¡ 23 ¡ 42 ¡ 16 ¡ 15 ¡ 8 ¡ 4 ¡ 42 ¡ 23 ¡ 16 ¡ 15 ¡ 8 ¡ 4 ¡ 42 ¡ 23 ¡ 16 ¡ 15 ¡ 8 ¡ 4 ¡

Code ¡

void ¡selectSort(int ¡a[], ¡int ¡size) ¡{ ¡ for( ¡int ¡i ¡= ¡0; ¡i ¡< ¡size-­‑1; ¡i++ ¡) ¡{ ¡ int ¡minPos ¡= ¡minimumPosiAon(a, ¡size, ¡i); ¡ swap(a, ¡minPos, ¡i); ¡ } ¡ } ¡ int ¡minimumPosiAon(int ¡a[], ¡int ¡size, ¡int ¡from) ¡{ ¡ int ¡minPos ¡= ¡from; ¡ for( ¡int ¡i ¡= ¡from ¡+ ¡1; ¡i ¡< ¡size; ¡i++ ¡) ¡ if( ¡a[i] ¡< ¡a[minPos] ¡) ¡minPos ¡= ¡i; ¡ return ¡minPos; ¡ } ¡ void ¡swap(int ¡a[], ¡int ¡i, ¡int ¡j) ¡{ ¡ int ¡temp ¡= ¡a[i]; ¡ a[i] ¡= ¡a[j]; ¡ a[j] ¡= ¡temp; ¡ } ¡

5 ¡

Complexity ¡

• We’ll ¡count ¡the ¡number ¡of ¡opera1ons ¡

selec1on ¡sort ¡takes ¡

• Simplifica1on: ¡count ¡how ¡oQen ¡an ¡array ¡

element ¡is ¡visited ¡ ¡

– propor1onal ¡to ¡the ¡number ¡of ¡opera1ons ¡

• Let ¡n ¡= ¡# ¡of ¡elements ¡in ¡array ¡

6 ¡

Complexity ¡ ¡

[i=0] ¡minimumPosi1on: ¡visits ¡n ¡elements ¡ ¡swap: ¡visits ¡2 ¡elements ¡ [i=1] ¡minimumPosi1on: ¡visits ¡n-­‑1 ¡elements ¡ ¡swap: ¡visits ¡2 ¡elements ¡ [i=2] ¡minimumPosi1on: ¡visits ¡n-­‑2 ¡elements ¡ ¡swap: ¡visits ¡2 ¡elements ¡ : ¡ [i=n-­‑2] ¡minimumPosi1on: ¡visits ¡2 ¡elements ¡ ¡swap: ¡visits ¡2 ¡elements ¡

7 ¡

Complexity ¡ ¡

Sum ¡the ¡numbers ¡on ¡the ¡previous ¡slide ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡<<<<<< ¡ ¡ Note ¡that ¡

8 ¡

2 +... + (n −1) = n(n +1) 2 −1

n + 2 +(n −1)+ 2 +•••+ 2 + 2

n +(n−)+•••+ 2 +(n −1)*2

2 +•••+(n −1)+ n +(n −1)*2

n(n +1) 2 −1+(n −1)*2

1 2 n + 5 2

2

n −3 = O(

2

n )

Inser1on ¡Sort ¡

• Assume ¡the ¡ini1al ¡sequence ¡a[0] ¡a[1] ¡… ¡a[k] ¡is ¡

already ¡sorted ¡

• k ¡= ¡0 ¡when ¡the ¡algorithm ¡starts ¡
• Insert ¡the ¡array ¡element ¡at ¡a[k+1] ¡into ¡the ¡

proper ¡loca1on ¡of ¡the ¡ini1al ¡sequence ¡

• Note ¡that ¡the ¡inser1on ¡enlarges ¡the ¡ini1al ¡(i.e. ¡

sorted) ¡sequence ¡

9 ¡

What ¡

10 ¡

4 ¡ 42 ¡ 15 ¡ 8 ¡ 16 ¡ 23 ¡ k(0) ¡ 4 ¡ 42 ¡ 15 ¡ 8 ¡ 23 ¡ k(1) ¡ 16 ¡ 4 ¡ 42 ¡ 15 ¡ 8 ¡ 23 ¡ 16 ¡

What ¡

11 ¡

4 ¡ 42 ¡ 15 ¡ 8 ¡ 16 ¡ 23 ¡ 4 ¡ 42 ¡ 15 ¡ 8 ¡ 23 ¡ 16 ¡ 4 ¡ 42 ¡ 15 ¡ 23 ¡ 16 ¡ 8 ¡ 4 ¡ 42 ¡ 23 ¡ 16 ¡ 15 ¡ 8 ¡ 4 ¡ 42 ¡ 23 ¡ 16 ¡ 15 ¡ 8 ¡ 42 ¡ 23 ¡ 16 ¡ 15 ¡ 8 ¡ 4 ¡

Code ¡

void ¡insertSort(int ¡a[], ¡int ¡size) ¡{ ¡ for( ¡int ¡i ¡= ¡1; ¡i ¡< ¡size; ¡i++ ¡){ ¡ int ¡next ¡= ¡a[i]; ¡ // ¡Find ¡the ¡inser1on ¡loca1on ¡ // ¡Move ¡all ¡larger ¡elements ¡up ¡ int ¡j ¡= ¡i; ¡ while( ¡j ¡> ¡0 ¡&& ¡a[j-­‑1] ¡> ¡next) ¡{ ¡

a[j] ¡= ¡a[j-­‑1]; ¡ j-­‑-­‑; ¡ } ¡

// ¡Insert ¡the ¡element ¡ a[j] ¡= ¡next; ¡ } ¡ } ¡

12 ¡

Complexity ¡ ¡

• for ¡loop ¡runs ¡for ¡(n-­‑1) ¡itera1ons ¡
• On ¡the ¡kth ¡itera1on: ¡

– We ¡have ¡k ¡elements ¡that ¡are ¡already ¡sorted ¡ – Need ¡to ¡insert ¡into ¡these ¡k ¡elements ¡and ¡move ¡up ¡ the ¡elements ¡that ¡are ¡past ¡the ¡inser1on ¡point ¡=> ¡k +1 ¡elements ¡visited ¡

• Total ¡# ¡of ¡visits ¡is: ¡ ¡ ¡

13 ¡

2 +3+...+ n = n(n +1) 2 = O(

2

n )

Complexity ¡of ¡Inser1on ¡Sort ¡

Best ¡Case-­‑ ¡ ¡ ¡already ¡in ¡order ¡ ¡O(n) ¡ ¡ Worst ¡Case-­‑ ¡ ¡ ¡reversed ¡ ¡ ¡O(n2) ¡ Average ¡Case-­‑ ¡ ¡ ¡ ¡ ¡ ¡ ¡O(n2) ¡ ¡

14 ¡

Bubble ¡Sort ¡

• Compare ¡adjacent ¡elements. ¡If ¡the ¡first ¡is ¡greater ¡

than ¡the ¡second, ¡swap ¡them. ¡

• Do ¡this ¡for ¡each ¡pair ¡of ¡adjacent ¡elements, ¡

star1ng ¡with ¡the ¡first ¡two ¡and ¡ending ¡with ¡the ¡ last ¡two. ¡At ¡this ¡point ¡the ¡last ¡element ¡should ¡be ¡ the ¡greatest. ¡

• Repeat ¡the ¡steps ¡for ¡all ¡elements ¡except ¡the ¡last ¡
• ne. ¡
• Keep ¡repea1ng ¡for ¡one ¡fewer ¡element ¡each ¡1me, ¡

un1l ¡you ¡have ¡no ¡more ¡pairs ¡to ¡compare. ¡

15 ¡

Bubble ¡Sort ¡

16 ¡

4 ¡ 42 ¡ 15 ¡ 8 ¡ 16 ¡ 23 ¡ 4 ¡ 42 ¡ 15 ¡ 8 ¡ 23 ¡ 16 ¡ 4 ¡ 42 ¡ 15 ¡ 23 ¡ 8 ¡ 16 ¡ 4 ¡ 42 ¡ 23 ¡ 15 ¡ 8 ¡ 16 ¡ 4 ¡ 42 ¡ 23 ¡ 15 ¡ 8 ¡ 16 ¡ 42 ¡ 4 ¡ 23 ¡ 15 ¡ 8 ¡ 16 ¡

Bubble ¡Sort ¡

• The ¡largest ¡element ¡is ¡in ¡the ¡last ¡element ¡of ¡

the ¡array. ¡ ¡The ¡rest ¡of ¡the ¡array ¡is ¡s1ll ¡

• unsorted. ¡ ¡We ¡do ¡it ¡again ¡but ¡stop ¡at ¡n-­‑1. ¡ ¡ ¡

17 ¡

42 ¡ 4 ¡ 23 ¡ 15 ¡ 8 ¡ 16 ¡ 42 ¡ 4 ¡ 23 ¡ 15 ¡ 8 ¡ 16 ¡

Code ¡

void ¡bubbleSort(int ¡a[], ¡int ¡size) ¡{ ¡ for ¡(int ¡i ¡= ¡(size-­‑1); ¡i ¡>= ¡0; ¡i-­‑-­‑) ¡{ ¡ for ¡(int ¡j ¡= ¡1; ¡j<=i; ¡j++){ ¡ if ¡(a[j-­‑1] ¡> ¡a[j]){ ¡ // ¡Swap ¡elements ¡at ¡j-­‑1 ¡and ¡j ¡ int ¡temp ¡= ¡a[j-­‑1]; ¡ a[j-­‑1] ¡= ¡a[j]; ¡ a[j] ¡= ¡temp; ¡ } ¡ } ¡ } ¡ } ¡

18 ¡

Complexity ¡ ¡

19 ¡

Best ¡Case-­‑ ¡ ¡ ¡already ¡in ¡order ¡ ¡O(n2) ¡ ¡ Worst ¡Case-­‑ ¡ ¡ ¡reversed ¡ ¡ ¡O(n2) ¡ Average ¡Case-­‑ ¡ ¡ ¡ ¡ ¡ ¡ ¡O(n2) ¡ ¡ ¡

There ¡is ¡a ¡version ¡with ¡best ¡case ¡O(n) ¡ ¡