Review: Trees Binary Search Trees Sets in Java Collections API CS1102S: Data Structures and Algorithms 05 A: Trees II

Transcription

1 05 A: Trees II CS1102S: Data Structures and Algorithms Martin Henz February 10, 2010 Generated on Wednesday 10 th February, 2010, 10:54 CS1102S: Data Structures and Algorithms 05 A: Trees II 1

2 1 Review: Trees 2 3 CS1102S: Data Structures and Algorithms 05 A: Trees II 2

3 1 Review: Trees 2 3 CS1102S: Data Structures and Algorithms 05 A: Trees II 3

4 Trees in computer science Trees are ubiquitous in CS, covering operating systems, computer graphics, data bases, etc. CS1102S: Data Structures and Algorithms 05 A: Trees II 4

5 Trees in computer science Trees are ubiquitous in CS, covering operating systems, computer graphics, data bases, etc. Trees as data structures Provide O(log N) search operations CS1102S: Data Structures and Algorithms 05 A: Trees II 5

6 Trees in computer science Trees are ubiquitous in CS, covering operating systems, computer graphics, data bases, etc. Trees as data structures Provide O(log N) search operations Heaps Serve as basis for other efficient data structures, such as heaps CS1102S: Data Structures and Algorithms 05 A: Trees II 6

7 Example CS1102S: Data Structures and Algorithms 05 A: Trees II 7

8 Binary Trees Definition A binary tree is a tree in which no node can have more than two children. CS1102S: Data Structures and Algorithms 05 A: Trees II 8

9 Implementation ClassBinaryNode { / / accessible by other package r o u t i n e s Object element ; / / The data i n the node BinaryNode l e f t ; / / L e f t c h i l d BinaryNode r i g h t ; / / Right c h i l d } CS1102S: Data Structures and Algorithms 05 A: Trees II 9

10 1 Review: Trees 2 3 CS1102S: Data Structures and Algorithms 05 A: Trees II 10

11 Review: Trees Setup We would like to quickly find out if a given data item is included in a collection. CS1102S: Data Structures and Algorithms 05 A: Trees II 11

12 Review: Trees Setup We would like to quickly find out if a given data item is included in a collection. Example In an underground carpark, a system captures the licence plate numbers of incoming and outgoing cars. CS1102S: Data Structures and Algorithms 05 A: Trees II 12

13 Review: Trees Setup We would like to quickly find out if a given data item is included in a collection. Example In an underground carpark, a system captures the licence plate numbers of incoming and outgoing cars. Problem: Find out if a particular car is in the carpark. CS1102S: Data Structures and Algorithms 05 A: Trees II 13

14 Operations for Sets interface Set<T> { public void add ( T x ) ; / / same as i n s e r t ( T x ) ; } public void remove ( T x ) ; public boolean contains ( T x ) ;... CS1102S: Data Structures and Algorithms 05 A: Trees II 14

15 How About Lists, Arrays, Stacks, Queues? Problem with Lists, Arrays, Stacks, Queues With lists, arrays, stacks and queues, we can only access the collection using an index or in a LIFO/FIFO manner. CS1102S: Data Structures and Algorithms 05 A: Trees II 15

16 How About Lists, Arrays, Stacks, Queues? Problem with Lists, Arrays, Stacks, Queues With lists, arrays, stacks and queues, we can only access the collection using an index or in a LIFO/FIFO manner. Therefore, search takes linear time. CS1102S: Data Structures and Algorithms 05 A: Trees II 16

17 How About Lists, Arrays, Stacks, Queues? Problem with Lists, Arrays, Stacks, Queues With lists, arrays, stacks and queues, we can only access the collection using an index or in a LIFO/FIFO manner. Therefore, search takes linear time. How to avoid linear access? For efficient data structures, we often exploit properties of data items. CS1102S: Data Structures and Algorithms 05 A: Trees II 17

18 Example Review: Trees Simple license plates Let us say the license plate numbers are positive integers from 0 to CS1102S: Data Structures and Algorithms 05 A: Trees II 18

19 Example Review: Trees Simple license plates Let us say the license plate numbers are positive integers from 0 to Solution Keep an array incarpark of boolean values (initially all false). CS1102S: Data Structures and Algorithms 05 A: Trees II 19

20 Example Review: Trees Simple license plates Let us say the license plate numbers are positive integers from 0 to Solution Keep an array incarpark of boolean values (initially all false). insert ( i ) sets incarpark[i] to true CS1102S: Data Structures and Algorithms 05 A: Trees II 20

21 Example Review: Trees Simple license plates Let us say the license plate numbers are positive integers from 0 to Solution Keep an array incarpark of boolean values (initially all false). insert ( i ) sets incarpark[i] to true remove(i) sets incarpark[i] to false CS1102S: Data Structures and Algorithms 05 A: Trees II 21

22 Example Review: Trees Simple license plates Let us say the license plate numbers are positive integers from 0 to Solution Keep an array incarpark of boolean values (initially all false). insert ( i ) sets incarpark[i] to true remove(i) sets incarpark[i] to false contains( i ) returns incarpark[i]. CS1102S: Data Structures and Algorithms 05 A: Trees II 22

23 The Sad Truth Review: Trees Not all data items are small integers! In Singapore, license plate numbers start with 2 3 letters, followed by a number, followed by another letter. CS1102S: Data Structures and Algorithms 05 A: Trees II 23

24 The Sad Truth Review: Trees Not all data items are small integers! In Singapore, license plate numbers start with 2 3 letters, followed by a number, followed by another letter. But: one property remains We can compare two license plate numbers, for example lexicographically. CS1102S: Data Structures and Algorithms 05 A: Trees II 24

25 Lexicographic Ordering on License Plate Numbers First compare the first letters as in a dictionary e.g. SBX... < SCY..., SA... < SAB... CS1102S: Data Structures and Algorithms 05 A: Trees II 25

26 Lexicographic Ordering on License Plate Numbers First compare the first letters as in a dictionary e.g. SBX... < SCY..., SA... < SAB... If the letters are the same, use the following number e.g. SBX 100 < SBX 101 CS1102S: Data Structures and Algorithms 05 A: Trees II 26

27 Lexicographic Ordering on License Plate Numbers First compare the first letters as in a dictionary e.g. SBX... < SCY..., SA... < SAB... If the letters are the same, use the following number e.g. SBX 100 < SBX 101 If the letters and numbers are the same, use the final letter e.g. SBX 101 P < SBX 101 Q CS1102S: Data Structures and Algorithms 05 A: Trees II 27

28 The Comparable Interface API Interface Comparable interface Comparable<T> { public i n t compareto ( T o ) ; } CS1102S: Data Structures and Algorithms 05 A: Trees II 28

29 Mathematics of Comparable Ordering Instances of the Comparable interface are subject to a total ordering. For any two elements x and y, we know whether: x smaller then y: x.compareto(y) returns negative int x smaller then y: x.compareto(y) returns positive int x equals y: x.compareto(y) returns 0 CS1102S: Data Structures and Algorithms 05 A: Trees II 29

30 Type variables allow the programmer to refer to a type at multiple places. Example public s t a t i c <Any> SchemeList<Any> c o n c a t A l l ( SchemeList<SchemeList<Any>> a L i s t L i s t ) {... } CS1102S: Data Structures and Algorithms 05 A: Trees II 30

31 Wildcard Types Sometimes, a generic type is completely unrestricted. We use? without having to declare it. Example public s t a t i c i n t i t e r a t i v e L e n g t h ( SchemeList<?> a L i s t ) { i n t acc = 0; while (! a L i s t. i s N i l ( ) ) { a L i s t = a L i s t. cdr ( ) ; acc ++; } return acc ; } CS1102S: Data Structures and Algorithms 05 A: Trees II 31

32 Upper bounds for types Sometimes, a type variable must be bounded to restrict the types that it stands for to a class and all its sub-classes. Example interface C o l l e c t i o n <E> {... boolean add (E e ) ; boolean addall ( C o l l e c t i o n <? extends E> c ) ;... } CS1102S: Data Structures and Algorithms 05 A: Trees II 32

33 interface Comparable interface Comparable<T> { public i n t compareto ( T o ) ; } Invariance of generic types If Lion is a subtype of Animal, then Cage<Lion> is not a subtype of Cage<Animal>. CS1102S: Data Structures and Algorithms 05 A: Trees II 33

34 Invariance of generic types If Lion is a subtype of Animal, then Cage<Lion> is not a subtype of Cage<Animal>. CS1102S: Data Structures and Algorithms 05 A: Trees II 34

35 Invariance of generic types If Lion is a subtype of Animal, then Cage<Lion> is not a subtype of Cage<Animal>. Invariance of Comparable Therefore, if Animal implements Comparable<Animal>, Lion does not necessarily implement Comparable<Lion>. CS1102S: Data Structures and Algorithms 05 A: Trees II 35

36 Invariance of generic types If Lion is a subtype of Animal, then Cage<Lion> is not a subtype of Cage<Animal>. Invariance of Comparable Therefore, if Animal implements Comparable<Animal>, Lion does not necessarily implement Comparable<Lion>. Lower bounds for Comparable We want to allow Lion to implement Comparable<T> as long as T is a super type of Lion. CS1102S: Data Structures and Algorithms 05 A: Trees II 36

37 Lower bounds for Comparable We want to allow Lion to implement Comparable<T> as long as T is a super type of Lion. class BinarySearchTree <Any extends Comparable<? super Any>> {... } CS1102S: Data Structures and Algorithms 05 A: Trees II 37

38 Review: Trees Setup Keep items in a tree. Each node holds one data item. CS1102S: Data Structures and Algorithms 05 A: Trees II 38

39 Review: Trees Setup Keep items in a tree. Each node holds one data item. Idea The left subtree of a node V only contains items smaller than V and the right subtree only contains items larger than V. CS1102S: Data Structures and Algorithms 05 A: Trees II 39

40 Review: Trees Setup Keep items in a tree. Each node holds one data item. Idea The left subtree of a node V only contains items smaller than V and the right subtree only contains items larger than V. Search can then proceed top-down, starting at the root. If the search item is smaller than the item at the root, go down to the left, and if it is larger, go right. CS1102S: Data Structures and Algorithms 05 A: Trees II 40

41 Example Review: Trees Both trees are binary trees, but only the left tree is a search tree. CS1102S: Data Structures and Algorithms 05 A: Trees II 41

42 Implementation Review: Trees private s t a t i c class BinaryNode<AnyType>{ AnyType element ; BinaryNode<AnyType> l e f t ; BinaryNode<AnyType> r i g h t ; BinaryNode ( AnyType theelement ) { this ( theelement, null, null ) ; } BinaryNode ( AnyType theelement, BinaryNode<AnyType> l t, BinaryNode<AnyType> r t ) { element = theelement ; l e f t = l t ; r i g h t = r t ; } } CS1102S: Data Structures and Algorithms 05 A: Trees II 42

43 Implementation Review: Trees public class BinarySearchTree<AnyType extends Comparable<? super AnyType>> { private s t a t i c class BinaryNode<AnyType> {.. } private BinaryNode<AnyType> r o o t ; public BinarySearchTree ( ) { r o o t = null ; } public void makeempty ( ) { r o o t = null ; } public boolean isempty ( ) { return r o o t == null ; }... } CS1102S: Data Structures and Algorithms 05 A: Trees II 43

44 Implementation Review: Trees public class BinarySearchTree<AnyType extends Comparable<? super AnyType>> {... public boolean contains ( AnyType x ) { return contains ( x, r o o t ) ; } public AnyType findmin ( ) { / / findmax s i m i l a r i f ( isempty ( ) ) throw new UnderflowException ( return findmin ( r o o t ). element ; } public void i n s e r t ( AnyType x ) { r o o t = i n s e r t ( x, r o o t ) ; } public void remove ( AnyType x ) { r o o t = remove ( x, r o o t ) ; } CS1102S:... Data Structures and Algorithms 05 A: Trees II 44

45 Implementation of Search private boolean contains ( AnyType x, BinaryNode<AnyType> t ) { i f ( t == null ) return false ; i n t compareresult = x. compareto ( t. element ) ; i f ( compareresult < 0) return contains ( x, t. l e f t ) ; else i f ( compareresult > 0 ) return contains ( x, t. r i g h t ) ; else return true ; } CS1102S: Data Structures and Algorithms 05 A: Trees II 45

46 Insertion Review: Trees Idea Proceed like in search. If item is found, do nothing. If not, insert it in the last visited position. Example CS1102S: Data Structures and Algorithms 05 A: Trees II 46

47 Deletion Review: Trees Idea Proceed like in search. If item is not found, do nothing. If item is found, take action depending on node. CS1102S: Data Structures and Algorithms 05 A: Trees II 47

48 Deletion Review: Trees Idea Proceed like in search. If item is not found, do nothing. If item is found, take action depending on node. Leaf If the node is leaf, delete it from parent. CS1102S: Data Structures and Algorithms 05 A: Trees II 48

49 Deletion Review: Trees Idea Proceed like in search. If item is not found, do nothing. If item is found, take action depending on node. Leaf If the node is leaf, delete it from parent. One child If the node has one child, move the child to parent. CS1102S: Data Structures and Algorithms 05 A: Trees II 49

50 Example: Deletion of Node with One Child One child If the node has one child, move the child to parent. CS1102S: Data Structures and Algorithms 05 A: Trees II 50

51 Example: Deletion of Node with One Child One child If the node has one child, move the child to parent. CS1102S: Data Structures and Algorithms 05 A: Trees II 51

52 Deletion of Node with Two Children Idea Replace data with data of smallest child on the right; then delete smallest child on the right. CS1102S: Data Structures and Algorithms 05 A: Trees II 52

53 Deletion of Node with Two Children Idea Replace data with data of smallest child on the right; then delete smallest child on the right. Example CS1102S: Data Structures and Algorithms 05 A: Trees II 53

54 Average-case Average Depth If all insertion sequences are equally likely, the average depth of any node is O(log N) (proof in Chapter 7) CS1102S: Data Structures and Algorithms 05 A: Trees II 54

55 Average-case Average Depth If all insertion sequences are equally likely, the average depth of any node is O(log N) (proof in Chapter 7) Deletion introduces imbalance Deletion favours right subtree, and therefore trees become left-heavy on the long run. CS1102S: Data Structures and Algorithms 05 A: Trees II 55

56 Average-case Randomly generated binary search tree CS1102S: Data Structures and Algorithms 05 A: Trees II 56

57 Average-case Search tree after N 2 insert/delete CS1102S: Data Structures and Algorithms 05 A: Trees II 57

58 1 Review: Trees 2 3 CS1102S: Data Structures and Algorithms 05 A: Trees II 58

59 Sets Idea A Set (interface) is a Collection (interface) that does not allow duplicate entries. Sorted Sets A SortedSet (interface) assumes that the data items are comparable (using a Comparator operation). interface SortedSet<E> extends Set<E> Implementation The most common implementation of SortedSet is TreeSet. CS1102S: Data Structures and Algorithms 05 A: Trees II 59

60 Next Week Friday: Midterm Monday Lab: Lab tasks (attendance taken) Wednesday: Hashing Thursday: Tutorial on midterm solutions Friday: Priority Queues CS1102S: Data Structures and Algorithms 05 A: Trees II 60