ppts

1. Data Structures, Search and Sort
Algorithms
Kar-Hai Chu
karhai@hawaii.edu

2. Data structures
 Storage
 Insertion, deletion
 Searching
 Sorting
 Big O

3. Stacks
 LIFO
 Push, pop
 O(1) operations

4. Linked lists v. Arrays
 Linked lists:
– Resizable
– Insertion/deletion
 Arrays:
– Faster index
– O(1) lookup
– Preset size

5. Hash tables
 Keys and values
 O(1) lookup
 Hash function
– Good v fast
 Clustering
 Databases

6. Selection sort :-(
 O(n2)
 Algorithm:
– Find the minimum value
– Swap with 1st position value
– Repeat with 2nd position down

7. Insertion sort :-)
 O(n2)
 O(1) space
 Great with small number of elements
(becomes relevant later)
 Algorithm:
– Move element from unsorted to sorted list

8. Bubble sort :-(
 O(n2)
 Algorithm:
– Iterate through each n, and sort with n+1
element
 Maybe go n-1 steps every iteration?
 Great for big numbers, bad for small
 Totally useless?

9. Merge sort :-)
 O(nlogn)
 Requires O(n) extra space
 Parallelizable
 Algorithm:
– Break list into 2 sublists
– Sort sublist
– Merge

10. Quick sort :-)
 Average O(nlogn), worst O(n2)
 O(n) extra space (can optimized for O(logn))
 Algorithm:
– pick a pivot
– put all x < pivot in less, all x > pivot in more
– Concat and recurse through less, pivot, and more
 Advantages also based on caching, registry
(single pivot comparison)
 Variations: use fat pivot

11. Linear search :-(
 O(n)
 Examines every item

12. Binary search :-)
 Requires a sorted list
 O(log n)
 Divide and conquer

13. Trees
 Almost like linked lists!
 Traverse: Pre-order v. Post-order v. In-
order
 Node, edge, sibling/parent/child, leaf

14. Binary trees
 0, 1, or 2 children per node
 Binary Search Tree: a binary tree where
node.left_child < node.value and
node.right_child >= node.value

15. Balanced binary
trees
 Minimizes the level of nodes
 Compared with “bad” binary tree?
 Advantages:
– Lookup, insertion, removal: O(log n)
 Disadvantages:
– Overhead to maintain balance

16. Heaps (binary)
 Complete: all leafs are at n or n-1,
toward the left
 Node.value >= child.value
 In binary min/max heap
– Insert = O(logn) .. add to bottom, bubble-up
– deleteMax = O(logn) .. Move last to root
and bubble-down

17. Heapsort
 O(nlogn)
 Algorithm:
– Build a heap
– deleteMax (or Min) repeatedly
 O(1) overhead

18. Why bother?
 Tries (say trees)
– Position determines the key
– Great for lots of short words
– Prefix matching
 But..
– Long strings..
– Complex algorithms

19. Chess!
 Minimax:
 Alpha-beta pruning - pick a bag!
– ordering
B: B1 B: B2 B: B3
A: A1 +3 -2 +2
A: A2 -1 0 +4
A: A3 -4 -3 +1

20. Useful
 http://www.cs.pitt.edu/~kirk/cs1501/anim
ations/Sort3.html