This document discusses various data structures and algorithms. It covers common data structures like stacks, linked lists, arrays, hash tables, trees, and heaps. It also covers fundamental sorting algorithms like selection sort, insertion sort, bubble sort, merge sort, quicksort, and heapsort. Additionally, it discusses searching algorithms like linear search and binary search. The document provides brief descriptions of each concept and notes their time complexities.

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