Data Structures/Containers Overviews

1. Data Structures/ContainersOverviews Standard Containers plus properties

2. Consumers vs Producers • Intelligent Consumers of Data Structures know • What operations are supported • Complexity of operations • Memory costs of operations • In your code documentation, include costs if not O(1) • Isn’t this enough? • Can’t we let the theoreticians build great data structures and algorithms and use them? • Sometimes - but • may need to adapt the algorithms • Or reuse the ideas • Or even, be a producer

3. Review

4. Data Structures • Why these data structures? • experience shows these are general useful building blocks • Different classes of programs have different building blocks • Maybe more building blocks should be discovered. • Composition/ Hybrid data structure • can compose data structures • e.g. list of trees, hashtable of binary trees, trees can be implemented as list of lists • Hybrid algorithms also useful, e.g. quicksort+bubblesort.

5. Selecting a Data Structure • In TSP, suppose we move a city in a tour? • How should tour be represented? • In keeping a personal address book, add/delete a person • If managing a telephone directory that needs to print names in order • add/delete bank transactions • Spell checker vs spell corrector

6. Selecting a Data Structure • In TSP, suppose we add/delete a city to a tour? • How should tour be represented? • linked list • In keeping a personal address book, add/delete a person • hash table • If managing a telephone directory that needs to print names in order • sorted tree • add/delete bank transactions • queue, to maintain time-order (single point) • priority queue, multiple entry points

7. Selecting a Data Structure • Polynomials • methods: add, multiply, solve, factor, differentiate, integrate, find extrema,... • representation: • dense entries: array • position implicitly encodes degree • implicit information is more efficient • sparse entries: list of pairs (degree, coefficient) • information explicit • explicit information is more comprehensible

8. Class Polynomial • Constructor Polynomial(String s) e.g. New Polynomial(“3*x^3+ x^2+ 1”) Methods: void add(Polynomial p) void mult(Polynomial p) public void toString() Non-obvious private void simplify() private void sort() Theorem: guaranteed, absolute simplification is impossible.

9. Polynomial • Representation/implementation Array: size = maximum degree+1 Linked list: size = numbers of terms where term = pair(coeff, degree) Useful: class Term implements Comparable just define int compareTo(Object o)

10. Term Class Term implements Comparable { int coeff, exp; Term(int c, int e) { coeff = c; exp = e; } public int compareTo(Object o) { Term t = (Term)o; if (t.exp != exp) return t.exp- exp; else return (t.coeff-coeff); } }

11. Polynomial with collections • Collections.sort( linkedlist l) • will sort (in O(n* log n)) time the entries where the natural ordering (i.e. entries in l implement comparable) • Collections.sort(arraylist a) • same complexity • Collections.sort( linkedlist l, Comparator c) • you can change the ordering by defining a new object, a comparator. • A comparator is an interface with one method, • int compare(Object o1, Object o2) • Comparator and Comparables can be used to sort and find extrema (mininum or maximum)

12. Linked List • Methods • boolean isEmpty() • void insert(Object o) O(1) O(N) if ordered • void delete(Object o) O(N) even if ordered • … find(Object o) O(N) even if ordered • Uses: • languages like LISP, Scheme, CLOS are based on lists • everything can be done with lists • one-size fits all => expensive

13. Ordered Linked List • Methods • boolean isEmpty() • void insert(Object o) O(N) • void delete(Object o) O(N) • … find(Object o) O(N) • Not great performance for work done. • OK if list short.

14. Lists • Types of lists: circular, singly-linked, double-linked, ordered lists, list of lists = trees • Implementable as dynamic arrays • if insert(o) overflows array, allocated a new array that is twice as large. • In Collections, LinkedList is a doubly linked list • boolean contains(Object o) • boolean add(Object o) • boolean remove(Object o) • Iterator iterator() • supports hasNext(), next() and remove() • What type of list do you need?

15. Dynamic Arrays • What’s the problem with ordinary arrays? • Overflow • Replace array by new class DynamicArray. • When array overflows, allocate twice as much space and copy old values into new array. • Comparison with linked list • Storage: depends on size of objects • For primitives, dynamic arrays require less storage. • Time: depends on operations • adding at head bad, at end good. • Know your domain. What operations occur? Frequency?

16. Splay Lists • Splaying is a new idea: Probabilistic ordering • No moving of elements on inserts, but on finds. • The goal is have good average (amortized) performance for finding elements. • Insert(object o) O(1) just add to front • Remove(object o) O(N) no change • Find(object o) O(N) worse case • p*N on average where is p probability of o • Action: When you find o, move it to the front • General: if p1>p2>…pn are probabilities of o1…on, then list will (on average) look like o1->o2->…on. • Or the expect rank of oi is i.

17. Stack • Stack: Main Methods • void push(object) O(1) • void pop() O(1) • Object top() O(1) • boolean isEmpty() O(1) • Uses • hold functions calls (recursion) • test for balanced parenthesis • operator parsing • Easily implemented as singly linked-list

18. Stack Applications • Syntax checker • if next token is paren e.g. (, {,[, },),] ) • if open-paren, push on stack • if closed-paren, check if equals top of stack • if equals, pop, else return error • Evaluation of Postfix (or build a tree) • If token is operand, push on stack • If token is operator, let k be its arity • do k pops • apply operator to those elements • push result • Search trees (depth-first search: later in course) • Backtracking algorithms (later in course)

19. Queues: FIFO • Methods • void enqueue(Object o) adds object • Object dequeue() returns oldest object • boolean isEmpty() • void makeEmpty() • If no O notation, assume O(1) (time and memory) • Uses • model transactions • model requests • Implementable as doubly linked list easily • As array is a little tricky

20. Queues as Array • Assume that we have a large enough array • Otherwise we can use dynamic arrays • Idea: wrap around • front points to first entry stored (initialize to 0) • deque: remove and decrement front (mod array size) • back points to last entry stored (initialize to -1) • enqueue: increment (mod array size) and insert • if front == back, either empty or full so.. • Keep a count of number of elements stored.

21. Queue Applications • Simulations: • whenever multiple lines of customers and servers, e.g. at a bank, grocery store etc. • Search • breadth first search (later in course) • Topological Sorting (later in course) • File-Servers or printers in a network • Policy: first-come first serve • Other Policies: (Priority queues) • smallest job first • most important job first • ….

22. Basic Trees • Main Methods • boolean isEmpty() • void makeEmpty() • insert(Object o)/delete(Object o) O(log n) if balanced • boolean find(Object o) O(log n) if balanced • Uses • sorted record keeping, reporting and updating • dictionary, telephone directory,... • internal representation for programs in compilation • Language PROLOG based on trees • Everything can be done with trees • Game trees

23. Applications • Sorting e.g. heapsort and treesort • Expression Tree: evaluation of expression • Parse Tree: Compiler has 3 main steps • Parse into tokens • Organize tokens into a Parse Tree • Generate Code • Decision Tree • each internal node is a query • leaf nodes are conclusion • e.g. medicine, botany, etc • can be built automatically from data

24. Hash Tables • Main Methods • void insert(Object key, Object o) O(1) • void remove(Object key, Object o) O(1) • Object retrieve(Object key) O(1) • Amazing! • Uses • Whenever add/delete, but don’t care if sorted • dictionary but not employee records • problem with weekly/month reports • Symbol tables in compilers • what does a variable/function name refer to

25. Priority Queues • Not a Queue • Main Methods • void insert(Object o) O(log n) • Object findMin() O(1) • void delete(Object o) O(log n) • Uses • bank with multiple tellers • events: customers arrive, depart • process next event (min) • How many tellers needed to give good service • If few events, theoretically (queueing theory) works • With many events, simulate.

26. Graphs • Game Trees are often graphs • aids checkers and chess • State-space search (general planning) is a graph • states (representation of model of world) • operators: map states into next states • Path finding is searching through a graph • 1,000,000 queens problem (solved easily) • job scheduling • class/ta/room scheduling • critical-path analysis • flow analysis: traffic/water/electric/money/work flow

27. Summary • Data Structures are the foundation of programs • Wrong choice of data structure degrades program significantly. • Be Data Structure smart. • Data Structure are the engines underlying programs • a small part of the code • But major determining factor for performance