Your friends the Trees. Data Structures

Transcription

1 Your friends the Trees Data Structures

2 LETS PLAY A GAME! I guess a number from 1 to 100 You can ask me a yes/no question PRIZES!!

3 Your turn in pairs I guess a number from 1 to 100 You can ask a yes/no question

4 LETS PLAY A GAME! Can you write that as java code ( sketch ) Function exits. Boolean isit( int )

5 TRIAL 1 HOW MANY ATTEMPTS WILL THE PROGRAM TAKE TO GUESS A NUMBER for(int i = 1; i<100;i++ ) { if( IsIt(i)) { println( found it! ); } }

6 TRIAL 1 HOW MANY ATTEMPTS WILL THE PROGRAM TAKE TO GUESS A NUMBER for(int i = 1; i<100;i++ ) { if( IsIt(i)) { println( found it! ); break ; } }

7 Lets do this the dull way Bottom Top Mid

8 Lets do this the dull way Bottom Top Mid

9 Lets do this the dull way Bottom Top Mid

10 Lets do this the dull way Bottom Top Mid

11 Lets do this the dull way Bottom Top Mid

12 Lets do this the dull way Bottom Top Mid

13 Log2(n) NODES QUESTIONS

14

15 TRIAL 2 HOW MANY ATTEMPTS WILL THE PROGRAM TAKE TO GUESS A NUMBER int findit() { int bottom, int top; do { int mid = ((top - bottom)/2)+bottom ; if( isitgreaterthan( mid ) ) bottom = mid ; else top = mid ; } while( (bottom+1) < top ) ; return bottom; }

16 A short true story linking The floor of the opening of the olympic games The millennium bridge

17

18

19

20

21

22 What Order is this For each line a For each line b Does a intersect b? Next Next

23 A B C A A,A A,B A,C B B,A B,B B,C C C,A C,B C,C

24 A B C D A A,A A,B A,C A,D B B,A B,B B,C B,D C C,A C,B C,C C,D D D,A D,B D,C D,D

25 What Order is this For each line a For each line b Does a intersect b? Next Next 3 lines 9 tests 4 lines 16 tests 5 lines 25 tests 6 lines 36 tests N lines? Tests

26 What Order is this For each line a For each line b Does a intersect b? Next Next 3 lines 9 tests 4 lines 16 tests 5 lines 25 tests 6 lines 36 tests N lines N^2 Tests

27

28 Mac plus

29

30

31 O( N LOG 2 (N))

32

33 Remember Linked List Link Data Next link Class Link { Object data; Link nextlink ; }

34 BinaryTree Link Data Left link Right link Class BinaryTree { Object data; Tree left ; Tree right; }

35 BinaryTree Link Data Left link Right link Class BinaryTree { Object data; Tree left ; Tree right; } Class BinaryTree<THING> { THING data; Tree left ; Tree right; }

36 Binary A binary tree consists of a header, plus a number of nodes connected by links in a hierarchical data structure: Each node contains an element (value or object), plus links to at most two other nodes (its left child and right child). BinaryNode Data Left link Right link Data Left link Right link

37 Binary A binary tree consists of a header, plus a number of nodes connected by links in a hierarchical data structure: Each node contains an element (value or object), plus links to at most two other nodes (its left child and right child). BinaryNode Data Left link Right link Data Data Left link Right link Left link Right link

38 Trees don t need to be ordered 40 + A ( 3*2 ) + * 40 A 3 2

39 Trees don t have to be binary

40 I AM ROOT Trunk ( used in Source code control ) BRANCHES LEAF NOTES. NO I DON T GET IT ETHER I DON T THINK THESE PEOPLE GET OUT MUCH

41 Binary trees A leaf node is one that has no children (i.e., both its links are null). Every node, except the root node, is the left or right child of exactly one other node (its parent). The root node has no parent the only link to it is the header. The size of a binary tree is the number of nodes (elements). An empty binary tree has size zero. Its header is null.

42 Binary trees Each subtree is itself a binary tree. This gives rise to an equivalent recursive definition. A binary tree is: empty, or nonempty, in which case it has a root node containing an element, a link to a left subtree, and a link to a right subtree.

43 Recursion

44 Classic recursion In fibonacci series, next number is the sum of prev 0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55

45 Classic recursion In fibonacci series, next number is the sum of prev 0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55 long fibonacci(int n) { if (n <= 1) return n; else return fibonacci(n-1) + fibonacci(n-2); }

46 Classic recursion In fibonacci series, next number is the sum of prev 0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55 long fibonacci(int n) { if (n <= 1) return n; else return fibonacci(n-1) + fibonacci(n-2); }

47 Recursion

48 This is the loop version int findit() { int bottom, int top; do { int mid = ((top - bottom)/2)+bottom ; if( isitgreaterthan( mid ) ) bottom = mid ; else top = mid ; } while( (bottom+1) < top ) ; return bottom; }

49 int findit() { int bottom, int top; do { int mid = ((top - bottom)/2)+bottom ; if( isitgreaterthan( mid ) ) bottom = mid ; else top = mid ; } while( (bottom+1) < top ) ; return bottom; } int findit( int bottom, int top ) { if( (bottom+1) < top ) return bottom; int mid = ((top - bottom)/2)+bottom ; if( isitgreaterthan( mid ) ) return findit(mid, top ) ; else return findit( bottom, mid) ; }

50 Binary search tree A binary search tree (or BST) is a binary tree with the following property. For any node in the binary tree, if that node contains element elem: Its left subtree (if nonempty) contains only elements less than elem. Its right subtree (if nonempty) contains only elements greater than elem.

51 40 40,23,33,76,45,12,58,23,1

52 40,23,33,76,45,12,58,23,

53 33 40,23,33,76,45,12,58,23,

54 40,23,33,76,45,12,58,23,

55 40,23,33,76,45,12,58,23,

56 40,23,33,76,45,12,58,23,

57 0 DEPTH

58 DEPTH The depth of node N is the number of links between the root node and N. The depth of a tree is the depth of the deepest node in the tree. A tree consisting of a single node has depth 0. By convention, an empty tree has depth 1.

59 How to make to a treeset in Java TreeSet<Integer> treeset; treeset = new TreeSet<Integer>(); int bits[] = { 40,23,33,76,45,12,58,23,1 } ; for( int i : bits ) { } treeset.add( bits ) ;

60 I want to add my class to TreeSet import java.util.*; class MyClass implements { String mystring; int ignore; public MyClass( String it) { mystring = it ; } }

61 I want to add my class to TreeSet Must implement compareto and tell java you implement Comparable compareto Must return -1 ( less ) 1 ( greater ) 0 ( equal ) class MyClass implements Comparable<MyClass> { String mystring; int igmore; public MyClass( String it) { mystring = it ; } public int compareto( MyClass myb) { } return mystring.compareto( myb.mystring); }

62 I want to add my class to TreeSet TreeSet<MyClass> ts = new TreeSet<MyClass>(); // Add elements to the tree set ts.add(new MyClass("C")); ts.add(new MyClass("A")); ts.add(new MyClass("B")); ts.add(new MyClass("E")); ts.add(new MyClass("F")); ts.add(new MyClass("D")); for( MyClass it: ts ) { println(it); }

63 Balance The key to life is balance

64 What if we add things in order? 1,2,3,4,5,6.. A,B,C,D,E,F Abagle, Bob, Cathy

65 1 1,2,3,4,5,6.. A,B,C,D,E,F Abagle, Bob, Cathy 7

66 1 unbalanced 2 Balanced

67 unbalanced Balanced

68 1 A binary tree of depth d is balanced if all nodes at depths 0, 1,, d 2 have two children. Nodes at depth d 1 may have two/one/no children. Nodes at depth d have no children (by definition). A binary tree of depth 0 or 1 is always balanced unbalanced Balanced

69 Don t panic Java Trees are self balancing

70 Analysis (counting comparisons): No. of comparisons is the same as for BST search. If the BST is well-balanced: Max. no. of comparisons = int(log2 n) + 1 Best-case time complexity is O(log n). If the BST is ill-balanced: Max. no. of comparisons = n Worst-case time complexity is O(n).

71 What if?.. TreeSet<Integer> treeset; treeset = new TreeSet<Integer>(); int bits[] = { 1,2,3,4,5,6,7,8 } ; for( int i : bits ) { treeset.add( bits ) ; }

72 Searching a binary tree How fast

73

74

75

76

77 Analysis of search Analysis (counting comparisons): Let the BST s size be n. If the BST has depth d, the number of comparisons is at most d + 1. If the BST is well-balanced, its depth is floor(log2 n): Max. no. of comparisons = floor(log2 n) + 1 Best-case time complexity is O(log n). If the BST is ill-balanced, its depth is at most n 1: Max. no. of comparisons = n Worst-case time complexity is O(n).

78 LOG 2 (N) Fast

79 Observation: For any node N in a tree, there is exactly one sequence of links between the root node and N. The depth of node N is the number of links between the root node and N. The depth of a tree is the depth of the deepest node in the tree. A tree consisting of a single node has depth 0. By convention, an empty tree has depth 1.

80 Who was it? BREAK 10 minutes a teenager s end-of-term report noted that his English reading was weak, his French prose was very weak, his essays grandiose beyond his abilities, and his mathematical promise undermined by his untidy work. He must remember that Cambridge will want sound knowledge rather than vague ideas, his physics teacher wrote.

81 Welcome back A teenager s end-of-term report noted that his English reading was weak, his French prose was very weak, his essays grandiose beyond his abilities, and his mathematical promise undermined by his untidy work. He must remember that Cambridge will want sound knowledge rather than vague ideas, his physics teacher wrote.

82 101 Other uses for binary trees

83 Binary tree traversal: Visit all nodes (elements) of the tree in some predetermined order. We must visit the root node, traverse the left subtree, and traverse the right subtree. But in which order? In-order traversal: Traverse the left subtree, then visit the root node, then traverse the right subtree. Pre-order traversal: Visit the root node, then traverse the left subtree, then traverse the right subtree. Post-order traversal: Traverse the left subtree, then traverse the right subtree, then visit the root node.

84 A B B C A C C In-order Pre-order Post-order A B

85 A B B C A C Pre-order C In-order A B Post-order

86 In-order

87 In-order 1,12,23,33,40,45,58,

88 Pre-order

89 Pre-order 40,23,12,1,33,76,45,

90 Post-oder 1,12,33,23,58,45,76,

91 Just how fast is a binary tree?

92 Implementation of sets using BSTs Operation Algorithm Time complexity contains BST search O(log n)best O(n) worst add BST insertion O(log n)best O(n) worst remove BST deletion O(log n)best O(n) worst

93 Bottom line Binary trees can be very fast ( searching )

94 Pruning

95 Delete 33?

96 Delete 33? Easy

97 Delete 76?

98 Delete 76? Fairly easy 58

99 Delete 12?

100 Delete 12? Fairly easy 58

101 Delete 40?

102 Delete 40? Pick left leaf node

103 Delete 40? Pick left leaf node

104 Delete 40? Pick left leaf node Replace

105 Deleting can be pretty quick

106 Some uses of binary trees

107 2D trees

108 Games use BSP trees to hold models of the world

109 3D Tree Octtree

110 Quad tree

111 Star cloud simulation - look for close pairs

112 Hierarchical agglomerative clustering

113 Recommender systems

114 Less than

115 Less than

116 Range searching in java TreeSet NavigableSet<E> subset(e fromelement, boolean frominclusive, E toelement, boolean toinclusive) Returns a view of the portion of this set whose elements range from fromelement to toelement.

117 In Memory On Disk 58

118 Select * from Fruit where price > 1.22 SQL Database The Index is a tree which can be stored on disk.

119 Summary Trees can be binary - Can ordered or unordered Searching times can be very fast Pre-order, Post-order, in-order Depth Balance Range searches In java need to have compareto method