Introduction: Data Structures and ADTs - Student.cs.uwaterloo.ca ...

Sorting 

CS 234: Data Types and Structures 

Omer Beg 

David R. Cheriton School of Computer Science 

University of Waterloo 

Spring 2013 

Beg (CS, UW) 

CS234 - Data Structures 1

From Last Class … 

Binary Trees 

Beg (CS, UW) 

CS234 - Data Structures 2

Another implementation of 

ADT Priority Queue 

Implement an unbounded Priority Queue using 

a max-heap 

Store items with their priorities 

Use priorities to shape the heap 

Beg (CS, UW) CS234 - Data Structures 3

Heap-based Priority Queue 

Organization of data: 

_L – Python list to store items with priorities 

PriorityQueue() 

Set _L = [] 

isEmpty() 

Does len(_L) == 0 

len() 

Return len(_L) 


pq.enqueue(item, priority) 

Add item with priority to end of _L 

while item's priority > parent's priority: 

Swap item and parent 

Update indices for parent and child 


Adding 90: What actually happens 


And then … 


Efficiency of enqueue 

Adding to end of heap: 

List/Array: amortized 

List/Array: worst case 

"Sifting" up – 

Maximum iterations 

Steps per iterations 

Total 

Overall: Worst case= _____ Amortized=_____ 


pq.dequeue() => 

item with maximum priority 

Move last entry into root 

While parent's priority < max children's priority: 

Swap parent and child with higher priority 

Update indices for parent and child 


Efficiency of dequeue 

Removing/Swapping last and first of heap: 

List: amortized 

List: worst case 

Array: 

"Sifting" down – 

Maximum iterations 

Steps per iterations 

Total 

List Overall: Worst case= _____ Amortized=_____ 

Array Overall: Worst case= _____ Amortized=_____ 


Another use of heaps 

Suppose we have a list L. 

Create an empty heap 

for each x in L: 

Add x to the heap 

for ind in range(n-1,-1,0): 

Remove max from heap, place in L[ind] 

We have a sorting algorithm! 


Runtime of Heapsort 

Allocate array for heap to be same length as L 

Building the heap: 

Add is, at worst, O(log n) 

n elements added 

O(n log n) 

Refilling L: 

Remove is, at worst, O(log n) 

n elements removed 

O(n log n) 


Improvements to Heapsort 

Algorithm requires extra array/list for heap 

Use the original array/list instead 

In-place algorithm 

Requires O(1) additional memory 

Have L share its space with the heap when 

Constructing the heap, 

Re-filling the array 

Heap: Uses first part of array/list 


"in place" heapsort 

Insert first value into the heap: 

Insert 51 as new leaf, "sift up": 



Retrieving the sorted data 

Remove max from heap 

Place just past "end" of heap in array 

Repeat until heap "empty" 

Array is now in sorted order! 



Basics of Sorting 

L = [x 0 ,x 1 ,x 2 ,…,x n ] 

Collection of comparable data 

Comparable: 

Given two unequal values, can determine 

bigger and smaller 

For simplicity, 

Put into ascending order 


Desirable Properties 

Comparisons of keys: O(n log n) worst case 

Swaps: O(n) worst case 

In place: Requires O(1) additional memory 

Stable: Equal keys are not reordered 

Special Case Performance ('adaptive'): Runtime 

approaches O(n) for nearly sorted data 


A few basic sorts (to start) 

Bubble sort 

Selection sort 

Linear Insertion sort 

http://www.sorting-algorithms.com/ 

http://www.cs.uwaterloo.ca/~bwbecker/sorting 

Demo/ 

http://math.hws.edu/TMCM/java/xSortLab/

Introduction: Data Structures and ADTs - Student.cs.uwaterloo.ca ...

Create successful ePaper yourself

Delete template?

Save as template?