Download
1 / 26
280 likes | 460 Vues
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.
E N D
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: Terminology • Ais the root node • Bis the parentof D and E • Cis the siblingof B • Dand E are the children of B • D, E, F, G, I are external nodes, or leaves • A, B, C, Hare internal nodes • The depth, level, orpath length of Eis 2 • The heightof the tree is 3 • The degreeof node Bis 2
Trees: Viewed Recursively A sub-tree is also a tree!!
Binary Trees • Binary tree: tree with all internal nodes of degree max 2 • Recursive View: a binary tree is either • empty • an internal node (the root) and two binary trees(left subtreeand 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 Traversal Algorithm preOrder(v) “visit” node v for each child wof vdo recursively perform preOrder(w) • Example: reading a document from beginning to end
Traversing Trees: Postorder • Postorder Traversal AlgorithmpostOrder(v) for each child wof vdo 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 v else let o be the operator stored at v x 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 v recursively perform inOrder(rightChild(v)) • Example: printing an arithmetic expression • print “(“ before traversing the left subtree • print “)” after traversing the right subtree
The BinaryNode in Java • A 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; } }
HR+1 HL+1 HR HL 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)
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 Preorder class 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 Postorder class 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 Inorder class 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: Properties • Maximum 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.
