Announcements. Midterm exam 2, Thursday, May 18. Today s topic: Binary trees (Ch. 8) Next topic: Priority queues and heaps. Break around 11:45am

Transcription

1 Announcements Midterm exam 2, Thursday, May 18 Closed book/notes but one sheet of paper allowed Covers up to stacks and queues Today s topic: Binary trees (Ch. 8) Next topic: Priority queues and heaps Break around 11:45am 1

2 Hierarchical data structures So far, we ve been studying linear structures An array s memory layout and a linked list s link pointers define an underlying linear order Now, hierarchical or branching structures Trees! 2

3 Motivation for trees For arrays: the insert operation is Θ(n) searching is Θ(n) or Θ(log n) For linked lists: the insert operation is Θ(1) (but Θ(n) to find the right spot) searching is Θ(n) (even if the list is sorted) Is there a data structure with Θ(log n) performance for all three operations: insert, remove, and search? Try tree! Reminder: n vs. log n n = 1,048,576 log 2 n = 20 3

4 Tree overview A tree is a collection of nodes with the following properties: each node contains or references data (the payload). If the collection is not empty, there is one node called the root which is the top of a hierarchy. All other nodes are connected to the root node with a unique path (implies nodes only have 1 parent node). Some examples: Family trees Organization charts Directory hierarchies Parse trees in a compiler a = (b + c) * d + d a = * b c 4

5 Trees tree: A directed, acyclic structure of linked nodes. directed : Has one-way links between nodes. acyclic : No path wraps back around to the same node twice. binary tree: One where each node has at most two children. A binary tree is either: empty, or a root node that contains: data, a left subtree, and 5 root 7 3 a right subtree Recursive definition of a recursive data structure! 5

6 Terminology node: an object containing a data value and left/right children root: topmost node of a tree leaf: a node that has no children internal node; neither the root nor a leaf parent: child: sibling: a node with a common parent root

7 Terminology (cont.) subtree: the tree of nodes reachable to the left/right from the current node height: length of the longest path from the root to any node (single element tree is height of 0) level or depth: length of the path from a root to a given node full tree: one where every internal node has 2 children Level 0 Level 1 height = 2 5 root 7 3 Level

8 A tree node for integers A basic tree node object stores data and refers to left/right left data right 42 Multiple nodes can be linked together into a larger tree left data right 42 left data right left data right left data right 86 8

9 Recursive data structures ---> recursive functions Number of nodes (size) in binary tree t: If t is empty size(t) = 0 else size(t) = 1 + size(leftsubtree(t)) + size(rightsubtree(t)) The height of binary tree t: If t is empty height(t) = -1 // want the height of a single node tree to be 0 else height(t) = 1 + max(height(leftsubtree(t)), height(rightsubtree(t))) 9

10 Full and complete trees A binary tree is full if each node is either a leaf node or a node that has 2 children. A perfect binary tree is a full binary tree with all leaf nodes at the same level. A binary tree T is complete if all levels except possibly the last are completely full, and the last level has all its nodes to the left side. Similar definitions but logically independent. 10

11 11

12 Max number of nodes The number of nodes in a perfect binary tree with h levels (0 through h)? At level h, there are 2 h nodes, so maxnodes = h = 2 h

13 Min and max number of levels, h What is the minimum number of levels of a full binary tree with n nodes? Let s use results from previous slide. n = 2 h 1 h min = log 2 (n+1) What is the maximum number of levels of a binary tree? This is a degenerate case... essentially a linked list! So: h max = n 13

14 Tree traversal Often we traverse a tree for various operations Three simple approaches: pre-order in-order post-order These are linear-time, depth-first traversals 14

15 Example: traversals A B C D E F G As you traverse depth-first, left-to-right, Preorder: print the element the first time you encounter it including null pointers A B D E C F G Inorder: print the element the second time you encounter it D B E A F C G Postorder: print the element the last time you encounter it D E B F G C A 15

16 Pre-order traversal Pre-order: root-left-right preorder(t) { if (t is not empty) { access the root element of t; preorder(leftsubtree(t)); preorder(rightsubtree(t)); 16

17 In-order traversal In-order: left-root-right inorder(t) { if (t is not empty) { inorder(leftsubtree(t)); access root element of t; inorder(rightsubtree(t)); 17

18 Post-order traversal Post-order: left-right root postorder(t) { if (t is not empty) { postorder(leftsubtree(t)); postorder(rightsubtree(t)); access the root element of t; 18

19 Tree traversals Level-order traversal Example of breadth-first traversal Pre-order, in-order, post-order traversals Example of depth-first traversal For a general tree (not a binary) In-order traversal not well defined Can do level-order, pre-order, post-order 19

20 Level-order traversal Begins at root, visits nodes one level at a time: 1, 2, 3,..., 10, 11 20

21 Example implementation: levelorder traversal You can see an implementation (levelorderprint) in BST.java that we will see later (see after you study the BST implementation first) Implementation uses a queue! 21

22 Binary Search Trees (BSTs) A BST t is a binary tree such that either t is empty, or 1. each element in leftsubtree(t) is less than root(t), and 2. each element in rightsubtree(t) is greater than root(t), and 3. both leftsubtree(t) and rightsubtree(t) are BSTs

23 Use of BSTs A tree as a set, e.g., java.util.treeset Spell checker Tree sort... A tree as a map, e.g., java.util.treemap Dictionary Address book... 23

24 Valid BST? Which of the trees shown are legal binary search trees? g m q b k x e

25 Searching a BST Describe an algorithm for searching the tree below for 31. Then search for value 6. root What is the maximum number of nodes you would need to examine to perform any search?

26 Recursive search pseudocode searchtreerec(node, key) { if (node is empty) return null if (key < node s key) return searchtreerec(node s left child, key) else if (key > node s key) return searchtreerec(node s right child, key) else return node 26

27 Iterative search pseudocode searchtree(node, key) { while (node is not empty) { if (key < node s key) node = node s left child else if (key > node s key) node = node s right child else return node 27

28 Intuitive search performance of BST For now, let s assume the binary tree splits in half at every node. Every time we descend to a child node we cut the number of remaining nodes to be searched in half. Sounds familiar? Θ(log n)! 28

29 Balanced? A balanced tree 2 An unbalanced tree

30 BSTs Performance: Search: Θ(log n) Insert: Θ(log n) Delete: Θ(log n)... on average... worst case is Θ(n) but this is rare there are strategies for avoiding the worst case 30

31 BST comparison Operation Theta Comparison (Average Case) BST Array-based List Linked List retrieve Θ(logN) Θ(logN) (?) Θ(N) insert Θ(logN) Θ(N) Θ(N) delete Θ(logN) Θ(N) Θ(N) 31

32 Some properties of BSTs The minimum node in a BST (or any of its subtrees) is the left-most node. To find the minimum node, we traverse down the left subtree until we find a node with an empty left child reference. The maximum node in a BST (or any of its subtrees) is the right-most node. To find the maximum node, we traverse down the right subtree until we find a node with an empty right child reference. An inorder traversal generates a list of the nodes in sorted order. This is the idea behind Tree Sort: put a random input sequence into a BST and then use an inorder traversal when you want the sorted sequence in a list. See successor method in BST.java (which is used in iterator) 32

33 Minimum and maximum value no left child so, minimum node no right child so, maximum node

34 findmin, iterative // returns the minimum value from this BST public int findmin() { if (root == null) { throw new NoSuchElementException(); return findminnode(root).element; private Node findminnode(node nptr) { if (nptr == null) return null; while (nptr.left!= null) { nptr = nptr.left; return nptr; root

35 findmin, recursive // returns the minimum value from this BST. public int findmin() { if (root == null) { throw new NoSuchElementException(); return findmin(root); private int findmin(node nptr) { if (nptr.left == null) { return nptr.element; else { return findmin(nptr.left); 29 root

36 Adding to a BST Add 14, and 3 in that order If the tree is empty, where should a new value be added? What is the general algorithm? Is the resulting tree unique when you add an element? 36

37 Adding an entry into a BST Add new entry as a leaf node. Descend down the tree checking each node s left or right subtrees to see if the new node can be added there. If the tree already has the element, don t add a duplicate. Otherwise, continue. When an empty left or right reference is found, create a node and attach it there. 37

38 Example add method Let s look at an iterative add() method. See BST.java, UseBST.java, Student.java Let s try a recursive add() method 38

39 An incorrect solution // Adds the given value to this BST in sorted order. public void addrec(int value) { add(root, value); private void add(node nptr, int value) { if (nptr == null) { nptr = new Node(value); else if (nptr.element > value) { add(nptr.left, value); else if (nptr.element < value) { add(nptr.right, value); // else nptr.element == value; // a duplicate (don't add) Why doesn't this solution work? What happens if you are adding a node to an empty tree! root

40 A recursive add public void addrec(int val) { if (root == null) { root = new Node(val, null); else { addrec(root, val); private static void addrec(node nptr, int val) { if (val > nptr.element) { if (nptr.right == null) nptr.right = new Node(val, nptr); // 2nd is parent else addrec(nptr.right, val); else if (val < nptr.element) { if (nptr.left == null) nptr.left = new Node(val, nptr); else addrec(nptr.left, val); 40

41 Another recursive add // Adds the given value to this BST in sorted order. public void add(int value) { root = add(root, value); private IntTreeNode add(node nptr, int value) { if (nptr == null) { nptr = new Node(value); else if (nptr.element > value) { nptr.left = add(nptr.left, value); else if (nptr.element < value) { nptr.right = add(nptr.right, value); // else a duplicate root 55 return nptr;

42 Removing a node First we must find the node to be deleted Once we ve found the node, there are three cases to consider. Case 1: The found node is a leaf node. Simplest case. Simply set the appropriate link in the parent to null. (Yes, each node has a parent reference!) Case 2: The found node is an interior node with 1 child Set the appropriate link in the parent to the found node s child. 42

43 Cases 1 and 2 for removal a leaf: replace with null a node with a left child only: replace with left child a node with a right child only: replace with right child root root root root t1.remove(55); t1.remove(-3); t1.remove(29); 43

44 Removing a node (cont.) Case 3: The found node is a node with 2 children. One approach is to find a successor node and replace the found node with it. The successor node is the node that would immediately follow the found node if all the nodes in the tree were laid out in a sorted linear manner (the next node from the found node in inorder traversal order). Where is this node? It s the minimum node in the right subtree i.e., the left-most node in the right subtree. Replace the found node s value with the successor node s value. Remove the successor node from the right subtree. Is the resulting tree unique when you remove a node? 44

45 Case 3 for removal a node with both children: replace it with min from right subtree root 55 t1.remove(55); root

46 Example remove method See BST.java, UseBST.java, Student.java 46

47 Recursive remove // Removes the given value from this BST, if it exists. public void remove(int value) { root = remove(root, value); private Node remove(node root, int value) { if (root == null) { return null; else if (root.element > value) { root.left = remove(root.left, value); else if (root.element < value) { root.right = remove(root.right, value); else { // root.element == value; remove this node if (root.right == null) { return root.left; // no R child; replace w/ L else if (root.left == null) { return root.right; // no L child; replace w/ R else { // both children; replace w/ min from R root.element = getmin(root.right); root.right = remove(root.right, root.element); return root; 47

48 Iterator Initialize it to point to the smallest element in the tree. Next() returns the next element in the inorder order in succession using the successor function. See BST.java 48

49 Tree shape We ve seen that the performance of search, add, and remove is dependent on the shape of the tree... specifically the tree s height. A balanced tree has a minimal height which gives the average case performance of Θ(log n). However, the shape of the tree is dependent on the order which entries are added. What kind of sequences are the worst balance-wise? 49

50 Tree balancing How to get a balanced tree? One approach: Sort the array of elements to be added to the tree Add the middle element of the input array, then the middle elements of the 2 halves, then the middle elements of the 4 fourths, etc. Problem: only works if we are given the input array upfront. In many cases the elements arrive asynchronously. What if we could balance the tree on the fly as elements are added and removed? 50

51 Self-balancing trees Two well-known algorithms for maintaining balance in a tree are: AVL Trees older technique that serves as a model for more modern techniques. Created by Russian mathematicians Georgii Adelson-Velskii and Evgenii Landis in Red Black Trees popular and efficient technique used in the Java Collections Framework. Developed in its modern form by Leonidas Guibas and Robert Sedgewick in Both algorithms utilize Tree Rotations. 51

52 Overview of AVL algorithm The AVL algorithm keeps track of how balanced a tree is by using a balance factor for each node. A node s balance factor is the height of the right subtree minus the height of the left subtree. A tree is unbalanced when the absolute value of the root s balance factor is greater than 1. When a new node is added that unbalances the tree, balance can be restored by performing either a single rotation or a double rotation. 52

53 Tree rotations See 53

54 Trees in Java Collections Framework The TreeSet class provides an implementation of the Set interface that utilizes a tree for storage. Objects are stored in sorted, ascending order. This is a balanced tree implementation. Note: as a set duplicates are not allowed. The TreeMap class provides storage and sorting of key-value pairs (see Map.Entry<K,V>). Entries are sorted by keys. Utilizes a red-black tree for storage. Note: keys as a set duplicate keys are not allowed although duplicate values are allowed. 54

55 What next? Study BST.java, UseBST.java, Student.java first Then: Priority queues and binary heaps next 55