Data Structures, Search and Sort Algorithms

Kar-Hai Chukarhai@hawaii.edu

Data structures

Storage Insertion, deletion Searching Sorting Big O

Stacks

LIFO Push, pop O(1) operations

Linked lists v. Arrays

Linked lists:– Resizable– Insertion/deletion

Arrays:– Faster index– O(1) lookup– Preset size

Hash tables

Keys and values O(1) lookup Hash function

– Good v fast Clustering Databases

Selection sort :-(

O(n2) Algorithm:

– Find the minimum value– Swap with 1st position value– Repeat with 2nd position down

Insertion sort :-)

O(n2) O(1) space Great with small number of elements

(becomes relevant later) Algorithm:

– Move element from unsorted to sorted list

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?

Merge sort :-)

O(nlogn) Requires O(n) extra space Parallelizable Algorithm:

– Break list into 2 sublists– Sort sublist– Merge

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

Linear search :-(

O(n) Examines every item

Binary search :-)

Requires a sorted list O(log n) Divide and conquer

Trees

Almost like linked lists! Traverse: Pre-order v. Post-order v. In-

order Node, edge, sibling/parent/child, leaf

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

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

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

Heapsort

O(nlogn) Algorithm:

– Build a heap– deleteMax (or Min) repeatedly

O(1) overhead

Why bother?

Tries (say trees)– Position determines the key– Great for lots of short words– Prefix matching

But..– Long strings..– Complex algorithms

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

Useful

http://www.cs.pitt.edu/~kirk/cs1501/animations/Sort3.html