Data Abstraction: Sets

1. Data Abstraction: Sets CMSC 11500 Introduction to Computer Programming October 21, 2002

2. Administration • Midterm Wednesday – in-class • Hand evaluations • Structures • Self-referential structures: lists, structures of structs • Data definitions, Templates, Functions • Recursion in Fns follow recursion in data def • Recursive/Iterative processes • Based on lecture/notes/hwk • Not book details • Extra office hrs: Tues 3-5, RY 178

3. Roadmap • Recap: Structures of structures • Data abstraction • Black boxes redux • Objects as functions on them • Example: Sets • Operations: Member-of?, Adjoin, Intersection • Implementations and Efficiency • Unordered Lists • Ordered Lists • Binary Search Trees • Summary

4. Recap: Structures of Structures • Family trees: • (Multiply) self-referential structures • Data Definition -> Template -> Function • (define-struct ft (name eye-color mother father)) • Where name, eye-color: symbol; mother, father: family tree • A family-tree: 1) ‘unknown, • 2) (make-ft name eye-color mother father)

5. Template -> Function (define (bea aft) (cond ((eq? ‘unknown aft) #f) ((ft? aft) (let ((bea-m (bea (ft-mother aft))) (bea-f (bea (ft-father aft)))) (cond ((eq ?(ft-eye-color aft) ‘blue) (ft-name aft)) ((symbol? bea-m) bea-m) ((symbol? bea-f) bea-f) (else #f)))))) (define (fn-for-ft aft) (cond ((eq? ‘unknown aft)..) ((ft? aft) (cond …(ft-eye-color aft)… …(ft-name aft)…. …(fn-for-ft (ft-mother aft)).. …(fn-for-ft (ft-father aft))…

6. Data Abstraction • Analogous to procedural abstraction • Procedure is black box • Don’t care about implementation as long as behaves as expected: contract, purpose • Data object as black box • Don’t care about implementation as long as behaves as expected

7. Abstracting Data • Compound data objects • Points, families, rational numbers, sets • Data has many facets • Also many possible representations • Key: Data object defined by operations • E.g. points: distance, slope, etc • Any implementation acceptable if performs operations specified

8. Data Abstraction: Sets • Set: Collection of distinct objects • Venn Diagrams • Defining functions • Element-of?: true if element is member of set • Adjoin: Adds element to set • Union: Set containing elements of input sets • Intersection: Set of elements in both input sets • Any implementation of these functions defines a set data object

9. Sets: Representations & Efficiency • Many possible representations: • Unordered lists • Ordered lists • Binary Search Trees • How choose among representations? • Efficiency: Order of growth • Tradeoffs in operations

10. Sets as Unordered Lists • A Set-of-numbers is: • 1) ‘() • 2) (cons n set-of-numbers) • Where n is number • Set: Each element appears once • Base template: • (define (fn-for-set set) • (cond ((null? set) …) • (else (…(car set) ….(fn-for-set (cdr set)))))

11. Member-of? (define (member-of x set) ; member-of: number set -> boolean ; true if x in set, false otherwise (cond ((null? set) #f) ((eq? (car set) x) #t) (else (member-of x (cdr set))))) Order of growth: Length of list: O(n)

12. Member-of? Hand-Evaluation (define (member-of x set) ; member-of: number set -> boolean ; true if x in set, false otherwise (cond ((null? set) #f) ((eq? (car set) x) #t) (else (member-of x (cdr set))))) (member-of 3 ‘(1 2 3 4)) (cond ((null? ‘(1 2 3 4)) #f) ((eq? (car ‘(1 2 3 4)) 3) #t) (else (member-of 3 (cdr ‘(1 2 3 4))))) (cond (#f #f) ((eq? (car ‘(1 2 3 4)) 3) #t) (else (member-of 3 (cdr ‘(1 2 3 4)))))

13. Hand-Evaluation Cont’d (cond (#f #f) ((eq? 1 3) #t) (else (member-of 3 (cdr ‘(1 2 3 4))))) (cond (#f #f) (#f #t) (else (member-of 3 (cdr ‘(1 2 3 4))))) (cond (#f #f) (#f #t) (else (member-of 3 ‘(2 3 4)))) (cond ((null? ‘(2 3 4)) #f) ((eq? (car ‘(2 3 4)) 3) #t) (else (member-of 3 (cdr ‘(2 3 4)))))

14. Hand-Evaluation Cont’d (cond ((#f #f) ((eq? (car ‘(3 4) 3) #t) (else (member-of 3 ‘(3 4)))) (cond (#f #f) ((eq? (car ‘(2 3 4) 3) #t) (else (member-of 3 (cdr ‘(2 3 4))))) (cond ((#f #f) ((eq? (car ‘(3 4) 3) #t) (else (member-of 3 ‘(3 4)))) (cond (#f #f) ((eq? 2 3) #t) (else (member-of 3 (cdr ‘(2 3 4))))) (cond ((#f #f) ((eq? 3 3) #t) (else (member-of 3 ‘(3 4)))) (cond (#f #f) (#f #t) (else (member-of 3 (cdr ‘(2 3 4)))) (cond ((#f #f) (#t #t) (else (member-of 3 ‘(3 4)))) (cond ((#f #f) (#f #t) (else (member-of 3 ‘(3 4)))) (cond ((null? ‘(3 4) #f) ((eq? (car ‘(3 4) 3) #t) (else (member-of 3 (cdr ‘(3 4))))) #t

15. Hand-Evaluation: Recursion Only (member-of 3 ‘(2 3 4)) (member-of 3 ‘(3 4)) ((eq? 3 3) #t) #t

16. Adjoin • Question: Single occurrence of element • Maintain at adjoin? Always insert? • Add condition to maintain invariant (one occurrence) • Order of Growth: Member-of? test: O(n) (define (adjoin x set) (cond ((null? set) (cons x set)) ((eq? (car set) x) set) (else (cons (car set) (adjoin x (cdr set))))) (define (adjoin x set) (if (member-of? x set) set (cons x set)))

17. Intersection (define (intersection set1 set2) ;intersection: set set -> set (cond ((null? set1) ‘()) ((null? set2) ‘()) ((member-of? (car set1) set2) (cons (car set1) (intersection (cdr set1) set2)) (else (intersection (cdr set1) set2))) • Order of growth: • Test every member of set1 in set2 • Member: O(n); Length of set1: O(n)  O(n^2)

18. Alternative: Ordered Lists • Set-of-numbers: • 1) ‘() • 2) (cons n set-of-numbers) • Where n is a number, and n <= all numbers in son • Maintain constraint: • Anywhere add element to set

19. Adjoin (define (adjoin x set) (cond ((null? set) (cons x ‘()) ((eq? (car set) x) set) ((< x (car set)) (cons x set)) (else (cons (car set) (adjoin x (cdr set)))))) Note: New invariant adds condition Order of Growth: On average, check half

20. Sets as Binary Search Trees • Bst: 1) ‘() • 2) (make-bstn val left right) • Where val is number; left, right are bst • All vals in left branch less than current, right gtr • (define-struct bstn (val left right)) 7 5 11 3 6 9 13

21. Adjoin: BST (define (adjoin x set) (cond ((null? set) (make-bstn x ‘() ‘()) ((= x (bstn-val set)) set) ((< x (bstn-val set)) (make-bstn (bstn-val set) (adjoin x (bstn-left set)) (bstn-right set))) ((> x (bstn-val set)) (make-bstn (bstn-val set) (bstn-left set) (adjoin x (bstn-right set))))

22. BST Sets • Analysis: • If balanced tree • Each branch reduces tree size by half Successive halving -> O(log n) growth

23. Summary • Data objects • Defined by operations done on them • Abstraction: • Many possible implementations of operations • All adhere to same contract, purpose • Different implications for efficiency

24. Next Time • Midterm • Hand evaluations • Structures • Self-referential structures: lists, structures of structs • Data definitions, Templates, Functions • Recursion in Fns follow recursion in data def