About This Lecture. Trees. Outline. Recursive List Definition slide 1. Recursive Tree Definition. Recursive List Definition slide 2

Transcription

1 Revised 21-Mar-05 About This Lecture 2 Trees In this lecture we study a non-linear container called a Tree and a special kind of Tree called a Binary Tree. CMPUT Lecture 18 Department of Computing Science University of Alberta Duane Szafron 03 Some code in this lecture is based on code from the book: Java Structures by Duane A. Bailey or the companion structure package 3 4 Outline Recursive List Definition slide 1 Recursive Structure Definitions Tree Terminology Binary Tree Interface Example - Expression Trees Binary Tree Implementation Tree Traversals Tree Property-based methods We can define a list recursively. A list is either empty or it contains two parts: a head element and the sublist consisting of the rest of the elements called the tail, where the sublist must be a list. Notice that by definition (since a list can be empty), the tail could be empty, so that the complete list could be a singleton list that has exactly one element. empty list singleton list head tail 5 6 Recursive List Definition slide 2 The term node is used to refer to an element at a particular location in a list so that each node contains an element. The relation between the head of a list and the head of its tail sublist is called a link or an edge and it is drawn as a line segment. node simplified view edges head tail head general list fully recursive tail view Recursive Tree Definition A tree is either empty or it contains two parts: a root element and a (possibly empty) list of subtrees, where each subtree is a tree. The term node is used to refer to an element at a particular location in a tree so that each node "contains" an element. Since each subtree is a tree it has its own root. The relation between the root of a tree and the roots of its subtrees is called an edge and it is drawn as a line segment. simplified view edges a node that contains 11 a different node that contains 11 1

2 7 8 Recursive Binary Tree Definition slide 1 Recursive Binary Tree Definition slide 2 A binary tree is a data structure that is not linear, but it can also be defined recursively. A binary tree is either empty or it contains three parts: a root element, a left binary subtree which is a binary tree and a right binary subtree, which is a binary tree. Notice that by definition (since a binary tree can be empty), both subtrees could be empty, so that the complete binary tree could be a singleton tree that has exactly one element. left subtree root empty binary tree singleton binary tree right subtree We can generalize the definitions of node and edge (link) to binary trees. The term node is used to refer to an element at a particular location in a binary tree so that each node contains an element. Since each binary subtree is a binary tree it has its own root. The relation between the root of a tree and the root of each of its subtrees is called a link or edge and is drawn as a line segment. 9 Recursive Binary Tree Definition slide 3 Tree Architecture left subtree root general binary tree right subtree fully recursive view Two trees are disjoint if they share no nodes and no edges. A forest is a set of disjoint trees. We can generalize the notion of subtree so that a tree T 1 is a subtree of a tree T 2 if all of the nodes and edges of T 1 are also in T 2. What we called a subtree before is now called a direct subtree. simplified view edges nodes forest a direct subtree some disjoint trees some subtrees Node Relationships Trees - node relationships example If node N 2 is the root of a direct subtree of node N 1, then node N 2 is a child of node N 1 and node N 1 is the parent of node N 2. The root node of a tree has no parent node in that tree. A node N 1 is an ancestor of a node N 2, if N 1 is the parent of node N 2 or if N 1 is the ancestor of a parent of N 2 (this is a recursive definition: ancestors(n) = parent(n) + ancestors(parent(n))). A node N 2 is a descendant of a node N 1, if N 1 is an ancestor of node N 2. A node with no children is called a leaf node. A node with children is called an interior node. Two nodes are siblings if they have the same parent. The ancestors of node 21 are nodes: and. The parent of node 21 is node. The children of node are nodes: 21, 17 and 67. The descendants of node are nodes: 21, 17, 67, 15, 11, 88 and 99. The leaf nodes are:, 21, 11, 88, 99, 13 and 90. The interior nodes are:,,, 17, 67 and 15. The siblings of node 21 are nodes: 17 and

3 13 14 Measuring Trees A path is the unique shortest sequence of edges from a node to an ancestor. The length of a path is the number of nodes in it. The height of a node is the length of the longest path from a leaf to the node. The height of a tree is the height of its root. The depth (level) of a node is the length of the path from the root to the node. The degree of a node is the number of children it has. The degree (arity) of a tree is the maximum degree of its nodes. Measuring Trees - Example The path from node 88 to node is highlighted in red. The length of the path from node 88 to node is 4. The height of node is 4. The height of the tree is the height of node : 5. The depth (level) of node 67 is the length of the path from node to node 67 which is 3. The degree of node is 3 and the degree of node is 2 and the degree of node 11 is 0. The degree of the tree is Binary Trees - terminology A binary tree is a tree in which nodes can have a maximum of 2 children. A binary tree is oriented if every node with 2 children differentiates between the children by calling them the left child and right child and every node with one child designates it either as a left child or right child. A node in a binary tree is full if it has arity 2. A full binary tree of height h has leaves only on level h and each of its interior nodes is full. A complete binary tree of height h is a full binary tree of height h with 0 or more of the rightmost leaves of level h removed. Binary Tree Examples Node is full in all trees since it has arity 2 in all of them. Node is full in the left tree, but not full in the middle tree where it has arity 0 and not full in the right tree where it has arity 1. full binary tree non-full but complete binary tree non-complete binary tree Binary Tree Traversals There are four common binary tree traversals: Preorder: process root then left subtree then right subtree Inorder: process left subtree then root then right subtree Postorder: process left subtree then right subtree then root Levelorder: process nodes of level i, before processing nodes of level i + 1 (not supported in the structure package) Processing of left and right subtrees is done recursively There are examples of why each traversal is useful, but in the lectures, we will only consider one example (expression evaluation) to show why one of the traversals (postorder) is useful. Binary Tree Traversals Example Preorder: Inorder: Postorder: Levelorder:

4 19 Postorder Expression Evaluation Postorder Traversal Example Consider the expression: (2+3) * 4 / (6-1) There are Java language precedence rules that order the operations: +, *, /, -. Normally, * and / have higher precedence than + and - so if the parentheses were not included, the * and / would be done first. When a compiler parses expressions in a programming language, it uses a binary tree to store the components of the expression. The compiler must ensure that the precedence is correct. One approach is for the compiler to produce a parse tree whose postorder traversal provides input for an evaluation stack that will evaluate the expression in the correct order. The rules for an evaluation stack are: when an operand (number) is processed during traversal, it is pushed onto the stack. when a binary operator is processed during traversal, two operands are popped from the stack, the binary operator is applied to the operands and the result is pushed onto the stack Postorder Traversal Example We will check our example expression to see if a postorder traversal and stack evaluator will correctly evaluate the expression. Here is the parse tree for the expression (2+3) * 4 / (6-1): * 4 / Postorder traversal: * / Stack evaluation of the traversal input: push 2 push 3 pop 3, pop 2, apply + and push 5 push 4 pop 4, pop 5, apply * and push push 6 push 1 pop 1, pop 6, apply - and push 5 pop 5, pop, apply / and push 4 Interface for Binary Trees The BinaryTree class in these lectures is significantly different than in the structure package. The structure package s BinaryTree is cursor-based but we will not have cursors. Our BinaryTree class implements the Collection interface. We will have an Interface for BinaryTree, the structure package does not BinaryTreeInterface (slide 1) public interface BinaryTreeInterface extends Collection { /* Inherited from Store mentioned here in comments for documentation purposes. public int size() // post: return the number of elements in the tree public boolean isempty() // post: return true iff the receiver is empty public void clear() // post: makes the receiver tree and all its subtrees empty */ BinaryTreeInterface (slide 2) /* Inherited from Collection mentioned here in comments for documentation purposes. public boolean contains(object anobject) // post: returns true iff the receiver contains anobject public Object remove(object anobject) // post: if receiver contains an element equal to anobject // one such element is removed and returned public Iterator elements() // post: returns an Iterator that goes through the // receiver's elements in inorder order. Use inorder as the "default" traversal since it is most intuitive. 4

5 26 BinaryTreeInterface (slide 3) BinaryTreeInterface (slide 4) public void add(object anobject) //post: anobject is added to the receiver. // It will be added as the root or a child of the // root if possible, otherwise recursively // in the left subtree (left chosen arbitrarily). */ // methods defined by BinaryTreeInterface start here public boolean hasleft() ; //post: returns true iff the receiver s left subtree // is non-empty public boolean hasright() ; //post: returns true iff the receiver s right subtree // is non-empty public boolean hasparent() ; //post: returns true iff the receiver has a parent BinaryTreeInterface (slide 5) BinaryTreeInterface (slide 6) public Object rootelement() ; //pre: receiver is not empty //post: returns the receiver's root element public BinaryTreeInterface left() ; //pre: receiver has a non-empty left subtree //post: returns the left subtree public BinaryTreeInterface right() ; //pre: receiver has a non-empty right subtree //post: returns the right subtree public BinaryTreeInterface parent() ; //pre: receiver has a parent //post: returns the parent public Iterator preorder() ; // post: returns an Iterator that goes through the receiver's // elements in preorder order. public Iterator postorder() ; // post: returns an Iterator that goes through the receiver's // elements in postorder order. public Iterator inorder() ; // post: returns an Iterator that goes through the receiver's // elements in inorder order BinaryTreeInterface (slide 7) Detach Example public void detachleftsubtree() ; //post: detaches the receiver's left subtree - it is the // same as before but is no longer a subtree. // The receiver has an empty left subtree. t t public void detachrightsubtree() ; //post: detaches the receiver's right subtree - it is the // same as before but is no longer a subtree. // The receiver has an empty right subtree. t.detachfromparent() public void detachfromparent() ; //post: detaches the receiver from its parent. The receiver // is the same tree as before but is no longer a subtree. // The parent has an empty subtree where the receiver // used to be. 5

6 31 32 BinaryTreeInterface (slide 8) BinaryTreeInterface (slide 9) public void attachleft(binarytreeinterface newleft) ; // pre: newleft is not empty, the receiver is not empty, // newleft!= receiver // post: newleft becomes the receiver's left subtree. // If the receiver had a left subtree it is detached. // If newleft had a parent, it is detached before being // attached to the receiver. public void attachright(binarytreeinterface newright) ; // pre: newright is not empty, the receiver is not empty, // newright!= receiver // post: newright becomes the receiver's right subtree. // If the receiver had a right subtree it is detached. // If newright had a parent, it is detached before being // attached to the receiver. public void attachparent(binarytreeinterface newparent, boolean onleft) ; // pre: newparent is not empty, the receiver is not empty, // newparent!= receiver // post: newparent becomes the receiver's Parent. // If the receiver had a parent it is detached. // If onleft is true the receiver becomes newparent's left // subtree; otherwise it becomes newparent's right subtree. // If newparent had a subtree on that side it is detached. public void setroot(object anobject) ; // post: the receiver's root element is anobject Binary Tree - Expression Evaluation BinaryTree Example - main() As an example of building a Binary Tree and using it, we will write a program that uses a Binary Tree and Stack to evaluate expressions. For example, here is the parsed form of the expression: (2+3) * 4 / (6-1) / public static void main(string args[]) { /* A Binary Expression Tree. */ BinaryTree tree; int value; tree = constructtree(); value = evaluatetree(tree); System.out.println(value); * code based on Bailey pg. 192 BinaryTree Example - constructtree() 35 BinaryTree Example - evaluatetree() slide 1 36 private static BinaryTree constructtree() { // post: return the example expression tree BinaryTree leftsubtree, rightsubtree, tree ; // build the tree from the bottom up leftsubtree = new BinaryTree(); leftsubtree.add("+"); leftsubtree.add(new Integer(2)); leftsubtree.add(new Integer(3)); tree = new BinaryTree(); tree.add("*"); tree.attachleft(leftsubtree) ; tree.add(new Integer (4)) ; leftsubtree = tree ; rightsubtree = new BinaryTree(); rightsubtree.add("-"); rightsubtree.add(new Integer(6)); rightsubtree.add(new Integer(1)); tree = new BinaryTree(); tree.add("/"); tree.attachleft(leftsubtree) ; tree.attachright(rightsubtree) ; return tree; private static int evaluatetree(binarytree tree) { // pre: (1) tree is not empty (2) all leaf nodes are Integers (3) all the inner nodes are strings of the form +, -. *, or / // post: return the int value of the given Tree. code based on Bailey pg

7 37 38 BinaryTree Example - evaluatetree() slide 1 Binary Tree - implementation private static int evaluatetree(binarytree tree) { // post: return the value of the given Tree. if (!three.hasleft() &&! Three.hasRight()) return tree.intvalue(); else if (this.rootelement().equals("+")) return evaluatetree(tree.left()+evaluatetree(tree.right()); else if (this.rootelement().equals( -")) return evaluatetree(tree.left()-evaluatetree(tree.right()); else if (this.rootelement().equals( *")) return evaluatetree(tree.left()*evaluatetree(tree.right()); else return evaluatetree(tree.left()/evaluatetree(tree.right()); code based on Bailey pg. 192 The Binary Tree class could be implemented like the linked list classes using an auxiliary class called BinaryTreeNode which would contain one element and have links to the parent node, the left child node and the right child node. To illustrate an alternative, we will not have a node class, only the BinaryTree class itself. A BinaryTree instance will contain its root element and links to its parent tree and left and right subtrees. Because we do not permit an element in a tree to be null we can represent the empty tree by setting its root element to null BinaryTree - state and Constructor public class BinaryTree implements BinaryTreeInterface { protected Object rootelement ; protected BinaryTreeInterface parent ; protected BinaryTreeInterface left ; protected BinaryTreeInterface right ; parent rootelement left right public BinaryTree() { // post: initializes a BinaryTree to be empty this.rootelement = null ; // indicates an empty tree this.parent = null ; this.left = null ; this.right = null ; BinaryTree Basic tests and access public boolean isempty() { // post: return true iff the receiver is empty return (this.rootelement == null) ; public boolean hasleft() { //post: returns true iff receiver has a non-empty left subtree return (this.left!= null) ; public Object rootelement() { //pre: receiver is not empty //post: returns the receiver's root element return this.rootelement ; public BinaryTreeInterface left() { //pre: receiver has a non-empty left subtree //post: returns the left subtree return this.left ; hasright(), hasparent() are similar right(), parent() are similar BinaryTree size BinaryTree contains public int size() { // post: return the number of elements in the receiver int size = 0 ; if (!this.isempty()) { size = 1 ; // count 1 for the root if (this.hasleft()) size = size + this.left.size() ; if (this.hasright()) size = size + this.right.size() ; return size ; public boolean contains(object anobject) { // post: returns true iff the receiver contains anobject if (this.isempty()) return false ; else { return this.rootelement.equals(anobject) (this.hasleft() && left.contains(anobject)) (this.hasright() && right.contains(anobject)); 7

8 44 BinaryTree add public void add(object anobject) { //post: anobject is added to the receiver. It will be added // as the root or a child of the root if possible, // otherwise recursively in the left subtree. if (this.isempty()) this.rootelement = anobject ; else { if (this.hasleft() && this.hasright()) { this.left().add( anobject ) ; else { if (!this.hasleft()) { this.left = this.newchild(anobject, this) ; else this.right = this.newchild(anobject,this) ; BinaryTree newchild [protected] protected BinaryTree newchild(object anobject, BinaryTreeInterface parent){ //post: create a new child leaf with anobject as its // element and "parent" as its parent BinaryTree newtree = new BinaryTree() ; newtree.rootelement= anobject ; newtree.parent = parent ; return newtree ; BinaryTree create Iterators BinaryTree detachleftsubtree public Iterator elements() { return inorder() ; // post: returns an Iterator that goes through the receiver's // elements in inorder order. public Iterator inorder() { // post: returns an Iterator that goes through the receiver's // elements in inorder order. Vector vector = new Vector(this.size()); BinaryTree.inorder(this, vector) ; return vector.elements() ; protected static void inorder(binarytreeinterface t, Vector vector) { // post: the elements of t are stored in vector in inorder order. if (!t.isempty()) { if (t.hasleft()) inorder(t.left(), vector) ; vector.addelement( t.rootelement() ) ; if (t.hasright()) inorder(t.right(), vector) ; preorder, postorder are similar public void detachleftsubtree() { // post: detaches the receiver's left subtree - it is the same // tree as before but is no longer a subtree. // The receiver has an empty left subtree. detachrightsubtree is similar if (this.left!= null) { BinaryTreeInterface temp = this.left ; this.left = null ; temp.detachfromparent() ; Why call temp.detachfromparent()? Why not just have temp.parent = null ; BinaryTree detachfromparent BinaryTree attachleft attachright is similar public void detachfromparent() { // post: detaches the receiver from its parent. The receiver // is the same tree as before but is no longer a subtree. // Parent has an empty subtree where the receiver used to be. if (this.parent!=null) { BinaryTreeInterface temp = this.parent ; this.parent = null ; if ( (temp.hasleft()) && (temp.left() == this)) { temp.detachleftsubtree(); if ( (temp.hasright()) && (temp.right() == this)) { temp.detachrightsubtree(); Why doesn t the call to detachleftsubtree cause an infinite loop? public void attachleft(binarytreeinterface newleft) { // pre: newleft is not empty, the receiver is not empty, // newleft!= receiver // post: newleft becomes the receiver's left subtree. // If the receiver had a left subtree it is detached. // If newleft had a parent, it is detached before being // attached to the receiver. if ((!this.hasleft()) (this.left()!= newleft)) { if (this.hasleft()) this.detachleftsubtree() ; this.left = newleft ; newleft.attachparent(this,true) ; Why call newleft.attachparent( )? Why not just have newleft.parent = this ; 8

9 49 50 BinaryTree attachparent BinaryTree clear, setroot public void attachparent(binarytreeinterface newparent, boolean onleft) { // pre: newparent is not empty, the receiver is not empty, // newparent!= receiver // post: newparent becomes the receiver's Parent. // If the receiver had a parent it is detached. // If onleft is true the receiver becomes newparent's left subtree; // otherwise it becomes newparent's right subtree. // If newparent had a subtree on that side it is detached. if (this.parent!= newparent) { if (this.hasparent()) this.detachfromparent() ; this.parent = newparent ; if (onleft) newparent.attachleft(this) ; else newparent.attachright(this) ; public void clear() { // post: makes the receiver tree and all its subtrees empty this.detachfromparent() ; Could we just set left and right to this.rootelement = null ; null & avoid using recursion? if (this.hasleft()) this.left.clear(); // will set left to null if (this.hasright()) this.right.clear(); // will set right to null public void setroot(object anobject) { // post: the receiver's root element is anobject this.rootelement = anobject ; Strategy for Removing an Element Find the element in the tree. Example: remove 1. Find the node containing. node If the element is in a leaf, delete the leaf. If the element is in an interior node, find a leaf beneath that node, delete the leaf, and replace the element by the leaf s element. 2. Find a leaf below that node. leaf below node 3. Delete the leaf. 4. Replace by the leaf element. node Binary Tree - remove Binary Tree find [protected] public Object remove(object anobject) { // post: if the receiver contains an element equal to anobject // one such element is is removed and returned; // otherwise does nothing. Object returnvalue ; BinaryTreeInterface where = find(this,anobject) ; if (where == null) return null ; returnvalue = where.rootelement() ; if ((!where.hasleft()) && (!where.hasright()) ) { where.clear() ; else { Object leafelement = findleafandremove(where) ; where.setroot( leafelement ) ; return returnvalue ; protected static BinaryTreeInterface find(binarytreeinterface t, Object anobject) { // post: if the receiver contains an element "equal to" anobject // returns a subtree having such an element at its root; // otherwise returns null. if (t.isempty()) { return null ; if (t.rootelement().equals(anobject)) { return t ; if (t.hasleft()) { BinaryTreeInterface where = find(t.left(), anobject) ; if (where!= null) { return where ; if (t.hasright()) { return find(t.right(), anobject) ; return null ; 9

10 56 Binary Tree findleafandremove [protected] protected static Object findleafandremove(binarytreeinterface t) { // post: removes a leaf node from the given tree, t, and returns // the leaf node s element in it. // Returns null if the given tree is empty. if (t.isempty()) return null ; if ((!t.hasleft()) && (!t.hasright()) ) { Object returnvalue = t.rootelement() ; t.clear() ; return returnvalue ; else { if (t.hasleft()) { return( findleafandremove(t.left()) ) ; else { return( findleafandremove(t.right()) ) ; External methods The following examples show how methods can be written outside the BinaryTree class. They are static, with a BinaryTreeInterface argument Binary Tree - depth public static int depth(binarytreeinterface t) { //pre: t is not empty //post: returns the depth of t's root node BinaryTreeInterface ancestor = t ; int depth = 1 ; while (ancestor.hasparent()) { ancestor = ancestor.parent() ; depth++ ; return depth ; Binary Tree - height public static int height(binarytreeinterface t) { //post: returns the height of the given tree (t). if (t.isempty()) return 0; else int lheight = 0 ; if (t.hasleft()) { lheight = height(t.left()); int rheight = 0 ; if (t.hasright()) { rheight = height(t.right()) ; return 1 + Math.max(lheight,rheight); time complexity: O(n) n = #nodes in the tree