Tree

Outline

• Tree Data Structure– Examples– Terminology & Definition

• Binary Tree• Tree Traversal

Trees: Some Examples

• A tree represents a hierarchy, for example:– Organizational structure of a company

Trees: Some Examples

– Table of contents of a book

Trees: Some Examples

– File system (Unix, Windows, Internet)

Trees: TerminologyA is the root nodeB is the parent of D and EC is the sibling of BD and E are the children of BD, E, F, G, I are external nodes, or

leavesA, B, C, H are internal nodesThe depth, level, or path length of E

is 2The height of the tree is 3The degree of node B is 2

Trees: Viewed Recursively

A sub-tree is also a tree!!

Binary TreesBinary tree: tree with all internal nodes of degree max 2Recursive View: a binary tree is either◦ empty◦ an internal node (the root) and two binary trees (left subtree

and right subtree)

Binary Trees: An Example• Arithmetic expression

Binary Trees: Properties• If we restrict that each parent can have two and only two children, then:

– |external nodes| = |internal nodes| + 1– |nodes at level i| 2i

– |external nodes| 2 (height)

– height log2 |external nodes|

– height log2 |nodes| - 1– height |internal nodes| = (|nodes| - 1)/2

Traversing Trees: Preorder

• Preorder TraversalAlgorithm preOrder(v)

“visit” node vfor each child w of v do

recursively perform preOrder(w)• Example: reading a document from beginning

to end

Traversing Trees: PostorderPostorder Traversal

Algorithm postOrder(v)for each child w of v do

recursively perform postOrder(w)“visit” node v

Example: du (disk usage) command in Unix

Traversing Trees• Algorithm evaluateExpression(v)if v is an external node

return the variable stored at velse

let o be the operator stored at vx evaluateExpression(leftChild(v))y evaluateExpression(rightChild(v))return x o y

Traversing Trees: Inorder• Inorder traversal of a binary tree

Algorithm inOrder(v)recursively perform inOrder(leftChild(v))“visit” node vrecursively perform inOrder(rightChild(v))

• Example: printing an arithmetic expression– print “(“ before traversing the left subtree– print “)” after traversing the right subtree

The BinaryNode in JavaA tree is a collection of nodes:

class BinaryNode <T>{ T element; /* Item stored in node */ BinaryNode<T> left; BinaryNode<T> right;

}

The tree stores a reference to the root node, which is the starting point.public class BinaryTree <T>{ private BinaryNode<T> root; // Root node

public BinaryTree() // Default constructor { root = null; }}

Think Recursively

• Computing the height of a tree is complex without recursion.

• The height of a tree is one more than the maximum of the heights of the subtrees.– HT = max (HL+1, HR+1)

HL HRHL+1

HR+1

Routine to Compute Height• Handle base case (empty tree)• Use previous observation for recursive case.

public static int height (BinaryNode t)

{

if (t == null)

return 0;

else

return 1 + max(height (t.left),

height (t.right));

}

Running Time

• This strategy is a postorder traversal: information for a tree node is computed after the information for its children is computed.

• The running time of tree traversal is N times the cost of processing each node.

• Thus, the running time is linear because we do constant work for each node in the tree.

Print Preorderclass BinaryNode{ void printPreOrder( ) { System.out.println( element ); // Node if( left != null ) left.printPreOrder( ); // Left if( right != null ) right.printPreOrder( ); // Right }}

class BinaryTree{ public void printPreOrder( ) { if( root != null ) root.printPreOrder( ); }}

Print Postorderclass BinaryNode{ void printPostOrder( ) { if( left != null ) left.printPostOrder( ); // Left if( right != null ) right.printPostOrder( ); // Right System.out.println( element ); // Node }}

class BinaryTree{ public void printPostOrder( ) { if( root != null ) root.printPostOrder( ); }}

Print Inorderclass BinaryNode{ void printInOrder( ) { if( left != null ) left.printInOrder( ); // Left System.out.println( element ); // Node if( right != null ) right.printInOrder( ); // Right }}

class BinaryTree{ public void printInOrder( ) { if( root != null ) root.printInOrder( ); }}

Traversing Tree

Pre-Order Post-Order InOrder

Level-Order Traversal

• Visit root followed by its children from left to right and followed by their children. So we go down the tree level by level.

• Sequence: A - B - C - D - E - F - G - H - I

Level-Order Traversal: Idea

• Using a queue instead of a stack• Algorithm (similar to pre-order)

– init: enqueue the root into the queue– while(true):

• node X = dequeue from the queue• visit/process node X;• enqueue left child of node X (if it exists); • enqueue right child of node X (if it exists);

Binary Tree: PropertiesMaximum number of nodes in a binary tree of height k is

2k+1 -1.A full binary tree with height k is a binary tree which has

2k+1 - 1 nodes.A complete binary tree with height k is a binary tree which

has maximum number of nodes possible in levels 0 through k -1, and in (k -1)’th level all nodes with children are selected from left to right.

Complete binary tree with n nodes can be shown by using an array, then for any node with index i, we have:◦ Parent (i) is at i/2 if i 1; for i =1, we have no parent.◦ Left-child (i ) is at 2i if 2i n. (else no left-child)◦ Right-child (i ) is at 2i+1 if 2i +1 n (else no right-child)

Summary Tree, Binary Tree In order to process the elements of a tree, we consider accessing the

elements in certain order Tree traversal is a tree operation that involves "visiting” (or" processing") all

the nodes in a tree. Depth First Search (DFS):

◦ Pre-order: Visit node first, pre-order all its subtrees from leftmost to rightmost.

◦ Inorder: Inorder the node in left subtree and then visit the root following by inorder traversal of all its right subtrees.

◦ Post-order: Post-order the node in left subtree and then post-order the right subtrees followed by visit to the node.

Breadth First Search (BFS):◦ Level-order: Visit root followed by its children from left to right and

followed by their children. So we go down the tree level by level.