COSC 1P03 Data Structures and Abstraction 20.1

COSC 1P03 

Data Structures and Abstraction 


Ch 20 

Searching & Sorting 

Data Structures and Abstraction 20.1 


Searching 

 

 

 

 

 

 

 

Locating one record (object) from a collection 

Search key 

unique vs duplicate 

Outcomes 

found/not found 

Simple vs exhaustive search 

Internal vs external 

Order 

significant step 

probe (checking key) 

simple O(n) 

best O(lg n) 

Key comparison search 

Data Structures and Abstraction 20.2 

loop 

determine point of next probe 

if no more choices then exit not found 

access item 

if search key matches key on item then exit found 

end 

Figure 20.1 Algorithm for key comparison search 

20.1




Sequential (Linear) Search 

 

 

 

 

 

Principle 

probe in order 

Algorithm 

as variation of basic search 

Simple vs exhaustive 

Analysis 

depends on where element is found 

average performance 

each probe eliminates 1 entry 

O(n) 

E.g. view student 


start at first item; 

for ( ; ; ) { 

if ( no more items ) { not found; break; }; 

access item 

if ( search key matches key on item ) { found; break; }; 

on to next item; 

}; 

Figure 20.2 Sequential search algorithm 

minimum O(1) 

maximum O(n) 

average 

O(n) 

Table 20.1 Order of sequential search 

20.2




Binary Search 

 

 

 

 

 

 

Large collections 

e.g. telephone book 

Requires - sorted by key 

Principle 

distribution of keys? 

probe at midpoint 

Algorithm 

probing 

bounds 

termination 

Analysis 

worst case 

each probe eliminates 1/2 remaining entries 

O(log n) 

E.g. view students 


start with bounds being first and last items; 

while ( true ) { 

if ( bounds empty ) { not found; break; }; 

access middle item between bounds 

if ( search key matches key on item ) { found; break; }; 

if ( search key greater than key on item ) { 

set lower bound to next item 

} 

else { 

set upper bound to prior item 

}; 

}; 

Figure 20.4 Binary search algorithm 

lower 

bound 

new upper 

bound 

upper 

bound 

probe 

Figure 20.5 Probe in binary search 

20.3



minimum O(1) 

maximum O(lg n) 

average O(lg n) 

Table 20.2 Order of Binary search 


Comparison 

 

 

 

 

 

Orders 

O(n) vs O(lg n) 

Requirements 

unsorted vs sorted 

Complexity of code 

programmer time 

maintenance 

Size of n 

n32 

Comparison statistics 

Data Structures and Abstraction 20.11 

Order Time (ms) 

sequential search O(n) 5,320 

binary search O(lg n) 50 

Table 20.3 Comparison of search algorithms 

20.4




Sorting 

 

 

 

 

 

 

Reports 

in name or id number order 

Ordering by key 

subsorts 

eg e.g. by course within department 

Sort key 

duplicate keys 

Internal vs external sorting 

In situ 

Stable 

depends on implementation 

required for subsorts 



Analysis 

 

 

 

Order 

key comparison 

simple O(n 2 ) 

best O(n lg n) 

Simple 

pass 

sorted & unsorted segments 

Better 

divide-and-conquer 


sorted 

unsorted 

pass 

Figure 20.7 Pass in sorting 

20.5




Selection Sort 

 

 

 

 

 

 

Principle 

select smallest (of remaining) and put it next 

Behavior 

last pass 

Algorithm 

find minimum (maximum) 

exchange 

Analysis 

O(n) comparisons each pass 

O(n) passes 

O(n 2 ) 

E.g. mark list by grade 

In situ, stable 


pass 1 

3 5 2 7 1 6 8 4 

pass 5 

1 2 3 4 5 6 8 7 

pass 2 

1 5 2 7 3 6 8 4 

pass 6 

1 2 3 4 5 6 8 7 

pass 3 

1 2 5 7 3 6 8 4 

pass 7 

1 2 3 4 5 6 8 7 

pass 4 1 2 3 7 5 6 8 4 

Figure 20.8 Selection sort 

pass 8 

1 2 3 4 5 6 7 8 


Insertion Sort 

 

 

 

 

 

Principle 

insert next entry (from unsorted) at correct point in sorted 

segment 

Behaviour 

first pass 

Analysis 

O(n) passes 

ave O(n) comparisons per pass 

O(n 2 ) 


shifting elements 



20.6



pass 1 

3 5 2 7 1 6 8 4 

pass 5 

3 5 2 7 1 4 6 8 

pass 2 

3 5 2 7 1 6 8 4 

pass 6 

3 5 2 1 4 6 7 8 

pass 3 

3 5 2 7 1 6 4 8 

pass 7 

3 5 1 2 4 6 7 8 

pass 4 3 5 2 7 1 4 6 8 

Figure 20.11 Insertion sort 

pass 8 

3 1 2 4 5 6 7 8 


 

 

 

 

 

Exchange (Bubble) Sort 

Principle 

exchange pairs if out of order 

works? 

quit? 

Pehaviour 

largest “bubbles” to end 

next pass doesn’t have to go to end 

Analysis 

each pass moves 1 item to correct spot 

O(n) passes 

ave O(n) pairs 

O(n 2 ) 

early termination 

no exchanges 

O(n) if sorted 

E.g. mark list in array 



pass 1 

3 5 2 7 1 6 8 4 

3 5 2 7 1 6 8 4 

pass 3 

2 3 1 5 6 4 7 8 

2 3 1 5 6 4 7 8 

3 2 5 7 1 6 8 4 

2 1 3 5 6 4 7 8 

3 2 5 7 1 6 8 4 

2 1 3 5 6 4 7 8 

3 2 5 1 7 6 8 4 

2 1 3 5 6 4 7 8 

3 2 5 1 6 7 8 4 

3 2 5 1 6 7 8 4 

pass 4 

2 1 3 5 4 6 7 8 

1 2 3 5 4 6 7 8 

pass 2 

3 2 5 1 6 7 4 8 

1 2 3 5 4 6 7 8 

2 3 5 1 6 7 4 8 

1 2 3 5 4 6 7 8 

2 3 5 1 6 7 4 8 

2 3 1 5 6 7 4 8 

2 3 1 5 6 7 4 8 

2 3 1 5 6 7 4 8 

pass 5 

pass 6 

1 2 3 4 5 6 7 8 

1 2 3 4 5 6 7 8 

1 2 3 4 5 6 7 8 

1 2 3 4 5 6 7 8 

1 2 3 4 5 6 7 8 

Figure 20.14 Exchange sort 

pass 7 

1 2 3 4 5 6 7 8 

20.7




Merge Sort 

 

 

 

 

Divide-and-conquer 

principle 

partition into two sets, sort & combine 

Merge sort 

partition 

break into two halves 

combine 

merge sorted partitions 

Behavior 

Analysis 

passes: O(lg n) 

partition: O(n) 

merge: O(n) 

complete: O(n log n) 


pass 1 

3 5 2 7 1 6 8 4 

pass 2 3 5 2 7 

1 6 8 4 

2 7 8 4 

pass 4 

3 

pass 3 3 5 1 6 4 

5 2 7 1 

6 

8 

4 

pass 3 

3 5 

2 7 1 6 4 8 

pass 2 2 3 5 7 1 4 6 8 

pass 1 

1 2 3 4 5 6 7 8 


Implementation 

 

 

 

 

 

 

Recursive 

trivial case: n=0, n=1 

reduction: n to 2 @ n/2 

Partition 

create two new arrays: left and left 

copy first half to left and second half to right 

Sort 

recursive 

Combine 

merge from left and right into original array 

special case, one side used up 


Stable, not in situ 


20.8



Order 

Time 

(ms) 

selection sort O(n 2 ) 4,610 

insertion sort O(n 2 ) 2,480 

exchange sort O(n 2 ) 9,120 

merge sort O(n lg n)

COSC 1P03 Data Structures and Abstraction 20.1

You also want an ePaper? Increase the reach of your titles

Delete template?

Save as template?