Transcript Tree

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: Terminology









A is the root node
B is the parent of D and E
C is the sibling of B
D and E are the children of B
D, E, F, G, I are external nodes, or
leaves
A, B, C, H are internal nodes
The depth, level, or path length of E
is 2
The height of the tree is 3
The degree of node B is 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 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 Traversal
Algorithm preOrder(v)
“visit” node v
for each child w of v do
recursively perform preOrder(w)
• Example: reading a document from beginning
to end
Traversing Trees: Postorder
 Postorder 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 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;
}
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+1
HR+1
HL
HR
•
•
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 );
if( left != null )
left.printPreOrder( );
if( right != null )
right.printPreOrder( );
}
}
class BinaryTree
{
public void printPreOrder( )
{
if( root != null )
root.printPreOrder( );
}
}
// Node
// Left
// Right
Print Postorder
class BinaryNode
{
void printPostOrder( )
{
if( left != null )
left.printPostOrder( );
if( right != null )
right.printPostOrder( );
System.out.println( element );
}
}
class BinaryTree
{
public void printPostOrder( )
{
if( root != null )
root.printPostOrder( );
}
}
// Left
// Right
// Node
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.