Lecture Topics. Object Structures. Hierarchical Organization. Tree Concepts. Hierarchical Organization. Hierarchical Organization

Transcription

1 Object Structures Trees CISH 4020 Tom Blough Lecture Topics Tree Concepts Traversals of a Tree Java Interfaces for Trees Examples of Binary Trees Examples of General Trees The Nodes in a Binary TreeinaryNode An Implementation of the ADT Binary Tree An Implementation of an Expression Tree General Trees Getting Started with Binary Search Trees Searching and Retrieving Traversing, Adding, and Removing Entries Efficiency of Operations Implementation of the ADT Dictionary Trees 2 Tree Concepts Hierarchical Organization Previous data organizations place data in linear order Some data organizations require categorizing data into groups, subgroups This is hierarchical classification Data items appear at various levels within the organization Example: File directories Trees 3 Trees 4 Hierarchical Organization Hierarchical Organization Example: A university's organization Example: Family trees Trees 5 Trees 6

2 Hierarchical Organization Tree Terminology Example: Family trees A tree is A set of nodes Connected by edges The edges indicate relationships among nodes Nodes arranged in levels Indicate the nodes' hierarchy Top level is a single node called the root Trees 7 Trees 8 Tree Terminology Tree Terminology Nodes at a given level are children of nodes of previous level Node with children is the parent node of those children Nodes with same parent are siblings Node with no children is a leaf node The only node with no parent is the root node All others have one parent each Trees 9 Trees 10 Tree Terminology Binary Trees Empty trees? Some authors specify a general tree must have at least the root node This text will allow all trees to be empty A node is reached from the root by a path The length of the path is the number of edges that compose it The height of a tree is the number of levels in the tree The subtree of a node is a tree rooted at a child of that node Each node has at most two children Trees 11 Trees 12

3 Binary Trees Binary Trees A binary tree is either empty or has the following form Where T left and T right are binary trees Every nonleaf in a full binary tree has exactly two children A complete binary tree is full to its nextto-last level Leaves on last level filled from left to right The height of a binary tree with n nodes that is either complete or full is log 2 (n + 1) Trees 13 Trees 14 Binary Trees The number of nodes in a full binary tree as a function of the tree's height. Traversals of a Tree Visiting a node Processing the data within a node This is the action performed on each node during traversal of a tree A traversal can pass through a node without visiting it at that moment For a binary tree Visit the root Visit all nodes in the root's left subtree Visit all nodes in the root's right subtree Trees 15 Trees 16 Traversals of a Tree Traversals of a Tree Preorder traversal: visit root before the subtrees Inorder traversal: visit root between visiting the subtrees Trees 17 Trees 18

4 Traversals of a Tree Traversals of a Tree Postorder traversal: visit root after visiting the subtrees Level-order traversal: begin at the root, visit nodes one level at a time These are examples of a depth-first traversal. This is an example of a breadth-first traversal. Trees 19 Trees 20 Traversals of a General Tree A general tree has traversals that are in Level order Preorder Postorder Inorder traversal not well defined for a general tree Traversals of a General Tree Trees 21 Trees 22 Java Interfaces for Trees Java Interfaces for Trees An interface that specifies operations common to all trees public interface TreeInterface { public Object getrootdata(); public int getheight(); public int getnumberofnodes(); public boolean isempty(); public void clear(); } // end TreeInterface Interface for iterators for various traversals import java.util.iterator; public interface TreeIteratorInterface { public Iterator getpreorderiterator(); public Iterator getpostorderiterator(); public Iterator getinorderiterator(); public Iterator getlevelorderiterator(); } // end TreeIteratorInterface Trees 23 Trees 24

5 Java Interfaces for Trees Interface for a class of binary trees public interface BinaryTreeInterface extends TreeInterface, TreeIteratorInterface { /** Sets an existing binary tree to a new one-node tree. rootdata a data object in the tree s root */ public void settree(object rootdata); /** Sets an existing binary tree to a new binary tree. rootdata a data object in the tree s root lefttree the left subtree of the new tree righttree the right subtree of the new tree */ public void settree(object rootdata, BinaryTreeInterface lefttree, BinaryTreeInterface righttree); } // end BinaryTreeInterface Trees 25 Java Interfaces for Trees A binary tree whose nodes contain one-letter strings. Trees 26 Examples of Binary Trees Examples of Binary Trees Expression Trees Algorithm for evaluating an expression tree in postorder traversal Algorithm evaluate(expressiontree) if (expressiontree is empty) return 0 else { firstoperand = evaluate(left subtree of expressiontree) secondoperand = evaluate(right subtree of expressiontree) operator = the root of expressiontree return the result of the operation operator and its operands firstoperand and secondoperand } Trees 27 Trees 28 Decision Trees A decision tree can be the basis of an expert system Helps users solve problems, make decisions Decision Trees A possible Java interface for a binary decision tree. public interface DecisionTreeInterface extends BinaryTreeInterface { /** Task: Gets the data in the current node. the data object in the current node */ public Object getcurrentdata(); /** Task: Determines whether current node contains an answer. true if the current node is a leaf */ public boolean isanswer(); /** Task: Moves the current node to the left (right) child */ public void advancetono(); public void advancetoyes(); /** Task: Sets the current node to the root of the tree.*/ public void reset(); } // end DecisionTreeInterface Trees 29 Trees 30

6 Decision Trees Decision Trees An initial decision tree for a guessing game. The decision tree for a guessing game after acquiring another fact. Trees 31 Trees 32 Binary Search Trees A search tree organizes its data so that a search is more efficient Binary search tree Nodes contain Comparable objects A node's data is greater than the data in the node's left subtree A node's data is less than the data in the node's right subtree Binary Search Trees Trees 33 Trees 34 Binary Search Trees Binary Search Trees An algorithm for searching a binary search tree Two binary search trees containing the same names as the previous tree Algorithm bstsearch(binarysearchtree, desiredobject) // Searches a binary search tree for a given object. // Returns true if the object is found. if (binarysearchtree is empty) return false else if (desiredobject == object in the root of binarysearchtree) return true else if (desiredobject < object in the root of binarysearchtree) return bstsearch(left subtree of binarysearchtree, desiredobject) else return bstsearch(right subtree of binarysearchtree, desiredobject) Trees 35 Trees 36

7 Heaps A complete binary tree Nodes contain Comparable objects Each node contains no smaller (or no larger) than objects in its descendants Maxheap Object in a node is its descendant objects Minheap Object in a node is descendant objects Heaps (a) A maxheap and (b) a minheap that contain the same values Trees 37 Trees 38 Examples of General Trees Examples of General Trees A parse tree for the algebraic expression a * (b + c) Trees 39 A portion of a game tree for tic-tac-toe Trees 40 Nodes in a Binary Tree Interface for a Node Interface for class of nodes suitable for a binary tree public interface BinaryNodeInterface { public Object getdata(); public void setdata(object newdata); public BinaryNodeInterface getleftchild(); public BinaryNodeInterface getrightchild(); public void setleftchild(binarynodeinterface leftchild); public void setrightchild(binarynodeinterface rightchild); public boolean hasleftchild(); public boolean hasrightchild(); public boolean isleaf(); } // end BinaryNodeInterface Trees 41 Trees 42

8 Implementation of BinaryNode Usually the class that represents a node in a tree is a detail hidden from the client It is placed within a package Makes it available Available to all classes involved in implementation of a tree An Implementation of the ADT Binary Tree Recall interface for class of binary trees from previous chapter In that interface TreeInterface specifies basic operations common to all trees TreeInteratorInterface specifies operations for tree traversal Note full implementation of BinaryTree, section 25.4 in text. Trees 43 Trees 44 The Method privatesettree Problem: previous implementation of privatesettree not sufficient Given: treea.settree (a, treeb, treec); Now treea shares nodes with treeb, treec Changes to treeb also affect treea (Fig. 25-2) The Method privatesettree Possible solution HaveprivatSetTree copy the nodes in TreeB and TreeC Now treea is separate and distinct from treeb and treec Changes to either treeb or treec do NOT affect treea Note that copying nodes is expensive Other solutions are considered Trees 45 Trees 46 The Method privatesettree Another possible solution for treea.settree( a, treeb, treec); HaveprivateSetTree first link the root node of treea to root nodes of treeb, treec (Fig. 25-3) Then set treeb.root, treec.root to null fig 25-3 here This still has some problems The Method privatesettree Real solution should do the following: 1. Create root node r for containing the data 2. If left subtree exists, not empty Attach root node to r as left child 3. If right subtree exists, not empty, distinct from left subtree Attach root node r as right child If right, left subtrees are the same, attach copy of right subtree to r instead 4. If left (right) subtree exists, different from the invoking tree object Set its data field root to null Trees 47 Trees 48

9 Accessor, Mutator Methods Methods implemented getrootdata() isempty() clear() setrootdata (Object rootdata) setrootnode (BinaryNode rootnode) getrootnode() Computing Height, Counting Nodes Within BinaryTree getheight() getnumberofnodes() Within BinaryNode getheight() getheight(binarynode node) getnumberofnodes() Trees 49 Trees 50 Traversals Make recursive method private Call from public method with no parameters Traversals public void inordertraverse() { inordertraverse(root); } private void inordertraverse(binarynode node) { if (node!= null) { inordertraverse((binarynode)node.getleftchild()); System.out.println(node.getData()); inordertraverse((binarynode)node.getrightchild()); } // end if } // end inordertraverse Trees 51 Trees 52 Traversals Traversals Using a stack to perform an inorder traversal of the previous binary tree. Using a stack to traverse the previous binary tree in preorder Trees 53 Trees 54

10 Traversals Traversals Using a queue to traverse the previous binary tree in level order. Using a stack to traverse the previous binary tree in postorder Trees 55 Trees 56 Implementation of an Expression Tree Defining an interface for an expression tree Extend the interface for a binary tree Add a declaration for the method evaluate public interface ExpressionTreeInterface extends BinaryTreeInterface { /** Task: Computes the value of the expression in the tree. the value of the expression */ public double evaluate(); } // end ExpressionTreeInterface General Trees A node for a general tree. Trees 57 Trees 58 Using a Binary Tree to Represent a General Tree Using a Binary Tree to Represent a General Tree An equivalent binary tree; Trees 59 Trees 60

11 Using a Binary Tree to Represent a General Tree Traversals Traversals of previous general tree in (a) Preorder: A B E F C G H I D J Postorder: E F B G H I C J D A Level order: A B C D E F G H I J Traversals of previous binary tree in (c) Preorder: A B E F C G H I D J Postorder: F E I H G J D C B A Level order: A B E C F G D H J I Inorder: E F B G H I C J D A A more conventional view Trees of the same binary tree. 61 Trees 62 Getting Started with Binary Search Trees Getting Started A binary search tree is a binary tree Nodes contain Comparable objects For each node in the tree The data in a node is greater than the data in the node's left subtree The data in a node is less than the data in the node's right subtree A binary search tree of names. Trees 63 Trees 64 An Interface for the Binary Search Tree An Interface for the Binary Search Tree import java.util.iterator; public interface SearchTreeInterface extends TreeInterface { public boolean contains(comparable entry); public Comparable getentry(comparable entry); public Comparable add(comparable newentry); public Comparable remove(comparable entry); public Iterator getinorderiterator(); } // end SearchTreeInterface Adding an entry that matches an entry already in a binary tree continued Trees 65 Trees 66

12 An Interface for the Binary Search Tree Duplicate Entries If duplicates are allowed, place the duplicate in the entry's right subtree. Adding an entry that matches an entry already in a binary tree. Trees 67 Trees 68 Beginning the Class Definition import java.util.iterator; public class BinarySearchTree extends BinaryTree implements SearchTreeInterface { public BinarySearchTree() { super(); } // end default constructor public BinarySearchTree(Comparable rootentry) { super(); setrootnode(new BinaryNode(rootEntry)); } // end constructor... Note that it is serializable because its base class BinaryTree is serializable. Trees 69 Searching and Retrieving Like performing a binary search of an array For a binary array Search one of two halves of the array For the binary search tree You search one of two subtrees of the binary search tree Trees 70 Searching and Retrieving Traversing The search algorithm Algorithm bstsearch(binarysearchtree, desiredobject) // Searches a binary search tree for a given object. // Returns true if the object is found. if (binarysearchtree is empty) return false else if (desiredobject == object in the root of binarysearchtree) return true else if (desiredobject < object in the root of binarysearchtree) return bstsearch(left subtree of binarysearchtree, desiredobject) else return bstsearch(right subtree of binarysearchtree, desiredobject) The SearchTreeInterface provides the method getinorderiterator Returns an inorder iterator Our class is a subclass of BinaryTree It inherits getinorderiterator This iterator traverses entries in ascending order Uses the entries' method compareto Trees 71 Trees 72

13 Adding an Entry Adding an Entry Recursively (a) A binary search tree; (b) the same tree after adding Chad. Trees 73 Recursively adding Chad to smaller subtrees of a binary search tree continued Trees 74 Adding an Entry Recursively Adding an Entry Recursively Recursively adding Chad to smaller subtrees of a binary search tree. The method addnode copies its argument (null) to its local parameter rootnode; (b) rootnode references a new node that contains Chad Trees 75 Trees 76 Adding an Entry Recursively After adding a node to the subtree passed to it, addnode returns a reference to the subtree so it can be attached to the rest of the original tree. Trees 77 Removing an Entry The remove method must receive an entry to be matched in the tree If found, it is removed Otherwise the method returns null Three cases The node has no children, it is a leaf (simplest case) The node has one child The node has two children Trees 78

14 Removing an Entry, Node a Leaf Removing an Entry, Node Has One Child (a) Two possible configurations of leaf node N; (b) the resulting two possible configurations after removing node N. Trees 79 (a) Four possible configurations of node N with one child; (b) resulting two possible configurations after removing Trees node N. 80 Removing an Entry, Node Has Two Children Removing an Entry, Node Has Two Children Two possible configurations of node N that has two children. Node N and its subtrees; (a) entry a is immediately before e, b is immediately after e; (b) after deleting the node that contained a and replacing e with a. Trees 81 Trees 82 Removing an Entry, Node Has Two Children Removing an Entry, Node Has Two Children The largest entry a in node N's left subtree occurs in the subtree's rightmost node R. Trees 83 (a) A binary search tree; Trees (b) after removing Chad; 84

15 Removing an Entry, Node Has Two Children Removing an Entry in the Root (a) Two possible configurations of a root that has one child; (b) after removing the root. (c) after removing Sean; Trees (d) after removing Kathy. 85 Trees 86 Iterative Implementation To locate the desired entry The remove method given entry to be matched If remove finds the entry, it returns the entry If not, it returns null The compareto method used to make comparisons with the entries in the tree Recursive Implementation Details similar to adding an entry The public remove method calls a private recursive remove method The public remove returns removed entry Privateremove must return root of revised tree Thus use parameter that is an instance of ReturnObject to return the value the public remove needs Trees 87 Trees 88 Efficiency of Operations Efficiency of Operations Operations add, remove, getentry require a search that begins at the root Maximum number of comparisons is directly proportional to the height, h of the tree These operations are O(h) Thus we desire the shortest binary search tree we can create from the data Two binary search trees that contain the same data. Trees 89 Shorter tree has efficiency O(log n) Trees 90

16 Importance of Balance Importance of Balance Completely balanced Subtrees of each node have exactly same height Height balanced Subtrees of each node in the tree differ in height by no more than 1 Completely balanced or height balanced trees are balanced Some binary trees that are height balanced. Trees 91 Trees 92 Importance of Balance The order in which entries are added affect the shape of the tree If entries are added to an empty binary tree Best not to have them sorted first Tree is more balanced if entries are in random order Trees 93 Implementation of the ADT Dictionary Interface for a dictionary import java.util.iterator; public interface DictionaryInterface { public Object add(object key, Object value); public Object remove(object key); public Object getvalue(object key); public boolean contains(object key); public Iterator getkeyiterator(); public Iterator getvalueiterator(); public boolean isempty(); public int getsize(); public void clear(); } // end DictionaryInterface Trees 94 Implementation of the ADT Dictionary Class of data entries (can be private, internal to class Dictionary) private class Entry implements Comparable, java.io.serializable { private Object key; private Object value; private Entry(Object searchkey, Object datavalue) { key = searchkey; value = datavalue; } // end constructor public int compareto(object other) { Comparable ckey = (Comparable)key; return ckey.compareto(((entry)other).key); } < The class also defines the methods getkey, getvalue, and setvalue; no setkey method is provided. >... } // end Entry Trees 95 Implementation of the ADT Dictionary Beginning of class Dictionary import java.util.iterator; public class Dictionary implements DictionaryInterface, java.io.serializable { private SearchTreeInterface bst; public Dictionary() { bst = new BinarySearchTree(); } // end default constructor... } // end Dictionary Trees 96