Download Trees

El-Shorouk Academy
Acad. Year
: 2010 / 2011
High Institute of Computer Science &
Term
Year
Information Technology
: 1st
: 3rd
Computer Science Department
Data Structures
Section (8)
Trees:
. Tree definition
 A type of data structure that represents the hierarchical data structure, in which each
element is attached to one or more elements directly beneath it.
Binary Tree
 A common use of tree is Binary Tree :
 It is characterized by the fact that any node can have at most two branches.

Two sample binary tree
A
B
D
H
C
E
F
A
B
G
I
C
D
E
Complete binary tree
skewed tree
 A fully binary tree of dept k has 2**k – 1 nodes
level
1
0
2
4
8
3
5
9 10
6
11 12 13
1
7
14
2
15
3
A fully Binary Tree of height 4
Binary tree Traversal
There are many operations can be performed on trees.
Traversing or viziting each node.
A full traversal produces a linear order for the information in a tree.
Inorder Traversal (Left-Root-Right)
 Traverse the left subtree in inorder
 Visit the root
 Traverse the right subtree in inorder.
4.2 Preorder Traversal ( Root-Left-Right)
4.3 Postorder Traversal ( Left-Right-Root )
A
B
C
D
E
G
H
F
I
J
Postorder : G D B H I E J F C A
Inorder
:DG B A H EI C J F
Preorder : A B D G C E H I F J
Binary Trees implimentation:
using System;
namespace BinaryTreeLibrary
{
// class TreeNode declaration
class TreeNode
{
private TreeNode leftNode; // link to left child
private int data; // data stored in node
private TreeNode rightNode; // link to right child
// initialize data and make this a leaf node
public TreeNode( int nodeData )
{
data = nodeData;
leftNode = rightNode = null; // node has no
children
} // end constructor
// LeftNode property
public TreeNode LeftNode
{
get
{
return leftNode;
} // end get
set
{
leftNode = value;
} // end set
} // end property LeftNode
// Data property
public int Data
{
get
{
return data;
} // end get
set
{
data = value;
} // end set
} // end property Data
// RightNode property
public TreeNode RightNode
{
get
{
return rightNode;
} // end get
set
{
rightNode = value;
} // end set
} // end property RightNode
// insert TreeNode into Tree that contains nodes;
// ignore duplicate values
public void Insert( int insertValue )
{
if ( insertValue < data ) // insert in left
subtree
{
// insert new TreeNode
if ( leftNode == null )
leftNode = new TreeNode( insertValue );
else // continue traversing left subtree
leftNode.Insert( insertValue );
} // end if
else if ( insertValue > data ) // insert in right
subtree
{
// insert new TreeNode
if ( rightNode == null )
rightNode = new TreeNode( insertValue );
else // continue traversing right subtree
rightNode.Insert( insertValue );
} // end else if
} // end method Insert
} // end class TreeNode
}
public class Tree
{
private TreeNode root;
// construct an empty Tree of integers
public Tree()
{
root = null;
} // end constructor
// Insert a new node in the binary search tree.
// If the root node is null, create the root node
here.
// Otherwise, call the insert method of class
TreeNode.
public void InsertNode( int insertValue )
{
if ( root == null )
root = new TreeNode( insertValue );
else
root.Insert( insertValue );
} // end method InsertNode
// begin preorder traversal
public void PreorderTraversal()
{
PreorderHelper( root );
} // end method PreorderTraversal
// recursive method to perform preorder traversal
private void PreorderHelper( TreeNode node )
{
if ( node == null )
return;
// output node data
Console.Write( node.Data + " " );
// traverse left subtree
PreorderHelper( node.LeftNode );
// traverse right subtree
PreorderHelper( node.RightNode );
} // end method PreorderHelper
// begin inorder traversal
public void InorderTraversal()
{
InorderHelper( root );
} // end method InorderTraversal
// recursive method to perform inorder traversal
private void InorderHelper( TreeNode node )
{
if ( node == null )
return;
// traverse left subtree
InorderHelper( node.LeftNode );
// output node data
Console.Write( node.Data + " " );
// traverse right subtree
InorderHelper( node.RightNode );
} // end method InorderHelper
// begin postorder traversal
public void PostorderTraversal()
{
PostorderHelper( root );
} // end method PostorderTraversal
// recursive method to perform postorder traversal
private void PostorderHelper( TreeNode node )
{
if ( node == null )
return;
// traverse left subtree
PostorderHelper( node.LeftNode );
// traverse right subtree
PostorderHelper( node.RightNode );
// output node data
Console.Write( node.Data + " " );
} // end method PostorderHelper
} // end class Tree
// class TreeTest declaration
public class TreeTest
{
// test class Tree
static void Main( string[] args )
{
Tree tree = new Tree();
int insertValue;
Console.WriteLine( "Inserting values: " );
Random random = new Random();
// insert 10 random integers from 0-99 in tree
for ( int i = 1; i <= 10; i++ )
{
insertValue = random.Next( 100 );
Console.Write( insertValue + " " );
tree.InsertNode( insertValue );
} // end for
// perform preorder traversal of tree
Console.WriteLine( "\n\nPreorder traversal" );
tree.PreorderTraversal();
// perform inorder traversal of tree
Console.WriteLine( "\n\nInorder traversal" );
tree.InorderTraversal();
// perform postorder traversal of tree
Console.WriteLine( "\n\nPostorder traversal" );
tree.PostorderTraversal();
} // end method Main
} // end class TreeTest