Trees Definition of a tree A tree is

Trees

Definition of a tree • A tree is like a binary tree, except that a node may have any number of children – Depending on the needs of the program, the children may or may not be ordered • Like a binary tree, a tree has a root, internal nodes, and leaves A • Each node contains an element and has branches leading to other nodes (its children) B C D E • Each node (other than the root) has a parent F G H I J K • Each node has a depth (distance from the root) L M N

More definitions • An empty tree has no nodes • The descendents of a node are its children and the descendents of its children • The ancestors of a node are its parent (if any) and the ancestors of its parent • The subtree rooted at a node consists of the given node and all its descendents • An ordered tree is one in which the order of the children is important; an unordered tree is one in which the children of a node can be thought of as a set

Data structure for a tree • A node in a binary tree can be represented as follows: class Binary. Tree. Node { Object value; Binary. Tree. Node left. Child, right. Child; } • However, each node in a tree has an arbitrary number of children, so we need something that will hold an arbitrary number of nodes, such as a Vector or a linked list class Tree. Node { Object element; Vector children; } • If we don’t care about the order of children, we might use a Set instead of a Vector

ADT for a tree • It must be possible to: – Construct a new tree • If a tree can be empty, this may require a header node – Add a child to a node – Get (iterate through) the children of a node – Access the value in a node • It should probably be possible to: – Remove a child – Get the parent of a node

The textbook Tree ADT, I • An interesting aspect of the Tree ADT described in the Java Collections textbook is that it uses an inner interface public interface Tree { //. . . method declarations. . . public interface Node { public Object get. Element(); public void set. Element(Object elem); } } • The inner interface is referred to by Tree. Node

The textbook Tree ADT, II public interface Tree { // Accessors public Tree. Node root(); public Tree. Node parent(Tree. Node node); public int child. Count(Tree. Node node); // Transformers public void make. Root(Object elem); public Tree. Node add. Child(Tree. Node node, Object elem); public void remove(Tree. Node node); // Iterator public Iterator children(Tree. Node node); // Inner interface for tree nodes public interface Node { public Object get. Element(); public void set. Element(Object elem); } }

Traversing a tree • You can traverse a tree in preorder: void preorder. Print() { System. out. println(this. element); Iterator iter = this. children. iterator(); while (iter. has. Next()) { preorder. Print(iter. next()); } } • You can traverse a tree in postorder: void postorder. Print() { Iterator iter = this. children. iterator(); while (iter. has. Next()) { postorder. Print(iter. next()); } System. out. println(this. element); } • You can’t usually traverse a tree in inorder – Why not?

Other tree manipulations • There’s really nothing new to talk about • A tree consists of nodes, each node has references to some other nodes—you know how to do all this stuff • There are some useful algorithms for searching trees, but (with minor modifications) they also apply to searching graphs, so we’ll do them later • Let’s move on to some applications of trees

Expression trees • Ordered trees can be used to represent arithmetic expressions + 2 2 The expression 2+2 * + * 3 4 The expression 2+3*4 2 4 3 The expression (2+3)*4 • To evaluate an expression (given as a node): – If it is a leaf, the element in it specifies the value • If the element is a number, that number is the value • If the element is a variable, look up its value in a table – If it is not a leaf, • Evaluate the children and combine them according to the operation specified by the element

Binary trees for expressions • You can use binary trees for expressions if you have only unary and binary operators • Java has a ternary operator if ? : > x y y The expression x > y ? x : y x = = y max x max y The statement if (x > y) max = x; else max = y; • Trees can be used to represent statements as well as expressions • Statements can be evaluated as easily as expressions

Writing compilers and interpreters • A compiler does three things: – Parses the input program (converts it into an abstract syntax tree) – (Optionally) optimizes the abstract syntax tree – Traverses the tree and outputs assembly language or machine code to do the same operations • An interpreter does three things: – Parses the input program (converts it into an abstract syntax tree) – (Optionally) optimizes the abstract syntax tree – Traverses the tree in an order controlled by the node contents, and performs the operations as it goes • Parsing is usually the hard part, but there is a very simple technique (called recursive descent parsing) that can be used if the language is carefully designed and you don’t care too much about efficiency or good error messages

I’ll never write a compiler. . . • Are you sure? • If you can’t parse text inputs, you are limited to reading simple things like numbers and Strings • If you can parse text input, you can make sense of: – – – tell Mary "Meet me at noon" fire phasers at 3, 7 17. 25, 0. 203 + 8. 97 i, 0. 95 i 28° 12"48' 3: 30 pm-5 pm • Parsing is less important in these days of GUIs, but it’s still pretty important – Java provides basic support for parsing with its String. Tokenizer and Stream. Tokenizer classes – Remember my Lisp applet?

Family trees • It turns out that a tree is not a good way to represent a family tree – Every child has two parents, a mother and a father – Parents frequently remarry • An “upside down” binary tree almost works – Since it is a biological fact (so far) that every child has exactly two parents, we can use left child = mother and right child = father – The terminology gets a bit confusing – There are lots of shared subtrees (since two people can have the same parent or parents) so what we have isn’t exactly a binary tree

Game trees • Trees are used heavily in implementing games, particularly board games • A node represents a position on the board • The children of a node represent all the possible moves from that position – More precisely, the branches from a node represent the possible moves; the children represent the new positions • Planning ahead (in a game) means choosing a path through the tree • However— – You can’t have a cycle in a tree – If you can return to a previous position in a game, you have a cycle – Graphs can have cycles

The End