BINARY TREE CSC248 – Data Structure

What is a TREE? Is a hierarchical structure that places elements in nodes along branches that originate from a root. Nodes in a tree are subdivided into levels in which the topmost level holds the root node. Any node in a tree can have multiple successors at the next level. A tree is a nonlinear structure. A tree can be viewed as a recursive data structure. Because trees are made up of subtrees.

What is a TREE? Examples of a tree structure

Tree Terminology

What is a BINARY TREE? It is a simplest form of a tree. is a tree data structure in which each node has at most two child nodes usually known as "left" and "right“ Any node in the data structure can be reached by starting at root node and repeatedly following references to either the left or right child.

What is a BINARY TREE? Examples of a binary tree data structure

Graphical Representation of Binary Tree

Properties of Binary Tree Branch Line from the root element to a subtree Leaf A leaf has no branches going down from it Height Number of branches between the root and the farthest leaf Level Number of branches between the root and element x Also known as element’s depth Path As sequence of element Level 1 2 3 branch Height of the tree = 3 Path between 2 to 5 = 2 7 6 5 leaf Example

Types of Binary Tree Strictly Binary Tree (SBT) Full Binary Tree (FBT) Each node that’s not a leaf has both left and right subtree Full Binary Tree (FBT) A tree with leaves only at the last level

BINARY SEARCH TREE (BST) sometimes also known as ordered or sorted binary tree, is a a node-based binary tree data structure which has the following properties:- The left subtree of a node contains only nodes with keys less than the node's key (All nodes in LEFT subtree are < ROOT node) The right subtree of a node contains only nodes with keys greater than or equal to the node's key (All nodes in RIGHT subtree are >= ROOT node) Both the left and right subtrees must also be binary search trees.

BINARY SEARCH TREE (BST) All nodes in LEFT subtree are < ROOT node All nodes in RIGHT subtree are >= ROOT node Both the left and right subtrees must also be binary search trees.

BINARY SEARCH TREE (BST) INORDER traversal on BST will give data in ascending order. PREORDER or POSTORDER traversal will give data in different order. The major advantage of binary search trees over other data structures is that the related sorting and search algorithms such as in-order traversal can be very efficient.

EXERCISE Identify the type of the following tree diagram:

EXERCISE Determine whether the following tree is a binary tree

TREE TRAVERSAL A tree data structure can store many information in a particular order to access and store. Accessing data in tree data structure is called tree traversal. Tree traversal is done recursively. Whenever a subtree is met, the traversal order starts again There are three common ways to traverse the tree :- In-order traversal (left, root, right) Pre-order traversal (root, left, right) Post-order traversal (left, right, root)

IN-ORDER TRAVERSAL For each tree or subtree – traversal starts from LEFT node, the ROOT and then the RIGHT node The algorithm, assuming that is a binary tree :

PRE-ORDER TRAVERSAL For each tree or subtree – traversal starts from ROOT node, the LEFT and then the RIGHT node The algorithm, assuming that is a binary tree

POST-ORDER TRAVERSAL For each tree or subtree – traversal starts from LEFT node, the RIGHT and then the ROOT node The algorithm, assuming that it is a binary tree

EXPRESSION TREE A binary expression tree represents an arithmetic expression (infix, prefix and postfix). In an expression tree, each operator is an interior node whose children as operands or subexpressions. Operands are in leaf nodes can be built with prefix and postfix expression only. Any infix expression must be converted to prefix or postfix expression in order to build the expression tree prefix or postfix expression will produce the same expression tree if it comes from the same infix expression

Building the Expression Tree Using Prefix Expression Evaluate prefix expression from LEFT to RIGHT. Any operator must be at the ROOT, and any operand must be at the leaf Always open the LEFT branch first until no more branch can be opened. Then open the RIGHT branch.

Building the Expression Tree

Using Postfix Expression Evaluate postfix expression from RIGHT to LEFT. Any operator must be at the ROOT, and any operand must be at the leaf Always open the RIGHT branch first until no more branch can be opened. Then open the LEFT branch.

Using Postfix Expression

TRAVERSING THE EXPRESSION TREE Applying a different traversing technique to an expression tree will result a different mathematical expression. There are three traversing technique : INORDER Traversal gives infix expression (LEFT, ROOT, RIGHT)  (OPERAND,OPERATOR,OPERAND) PREORDER Traversal gives prefix expression (ROOT, LEFT, RIGHT)  (OPERATOR,OPERAND,OPERAND) POSTORDER Traversal gives postfix expression (LEFT, RIGHT, ROOT)  (OPERAND,OPERAND,OPERATOR

Traverse the tree in inorder, preorder and postorder

INORDER TRAVERSAL The traversal result is: 3 + 7 * 2 -1

PREORDER TRAVERSAL The traversal result: - + 3 * 7 2 1

Post-order traversal The traversal result: 3 7 2 * + 1 -

Binary Search Tree Implementation BST uses dynamic storage space BST ADT has to be modified to suit the type of data to be stored. ADT can’t be common because data has to be compared to locate proper position. BST uses recursion method/technique. Each node in a tree has 3 elements : Left node reference/link Data Right node reference/link

Tree Node Structure (for primitive data type integer) Class : TreeNode Attributes: leftNode // left node reference/link rightNode // right node reference/link data // represent data Methods : Constructor() // normal constructor insert() // insert a TreeNode into a tree

//normal constructor to initialize data to d public TreeNode(int d) public class TreeNode { TreeNode left; TreeNode right; int data; //normal constructor to initialize data to d //and make this a leaf node public TreeNode(int d) left=right=null; data = d; } // Insert a TreeNode into a Tree that contains // contains nodes. Ignore duplicate values. public void insert( int d ) { if ( d < data ) if ( left == null ) left = new TreeNode( d ); else left.insert( d ); } if ( d > data ) if ( right == null ) right = new TreeNode( d ); right.insert( d );

Binary Search Tree Structure Class : BSTree Attributes: root // roott node reference Methods : public BSTree() // default constructor public void insertNode(element) public void preorderTraversal() private void preorderHelper(node) public void inorderTraversal() private void inorderHelper(node) public void postorderTraversal() private void postorderHelper(node)

// Insert a new node in the binary search tree. public class BSTree { TreeNode root; // Construct an empty Tree public BSTree() { root = null; } // 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 d ) if ( root == null ) root = new TreeNode( d ); else root.insert( d ); }

public void PreOrder() { RecurPreOrder( root ); } // Preorder Traversal public void PreOrder() { RecurPreOrder( root ); } // Recursive method to perform preorder traversal private void RecurPreOrder( TreeNode node ) if ( node == null ) return; System.out.print( node.data + " " ); RecurPreOrder( node.left ); RecurPreOrder( node.right );

private void RecurInOrder( TreeNode node ) if ( node == null ) return; // Inorder Traversal public void InOrder() { RecurInOrder( root ); } // Recursive method to perform inorder traversal private void RecurInOrder( TreeNode node ) if ( node == null ) return; RecurInOrder( node.left ); System.out.print( node.data + " " ); RecurInOrder( node.right );

public void PostOrder() { RecurPostOrder( root ); } // Postorder Traversal public void PostOrder() { RecurPostOrder( root ); } // Recursive method to perform postorder traversal private void RecurPostOrder( TreeNode node ) if ( node == null ) return; RecurPostOrder( node.left ); RecurPostOrder( node.right ); System.out.print( node.data + " " );

Main Application for Binary Search Tree (primitive data type integer) import java.util.*; public class BinaryTreeApp { public static void main(String[] args) Scanner s = new Scanner(System.in); BSTree tree = new BSTree(); //insert 5 integer numbers into a binary search tree for(int i = 1; i <= 5; i++) System.out.println("Enter an integer number"); int n = s.nextInt(); tree.insertNode(n); }

//Traverse the binary search tree System.out.println("Inorder Traversal"); tree.InOrder(); System.out.println("Postorder Traversal"); tree.PostOrder(); System.out.println("Preorder Traversal"); tree.PreOrder(); }

public int totalOrder(String productCode) { return recurTotalOrder(root, productCode); } private int recurTotalOrder(TreeNode node, String productCode) if (node == null) return 0; else Order o = (Order) node.data; return 0.getOrder() + recurTotalOrder(node.left, productCode) + recurTotalOrder(node.right, productCode);

public int countHandphoneBrand(String brand) { return countHP(root, brand); } private int countHP(TreeNode node, String brand) if (node == null) return 0; else Handphone h = (Handphone) node.data; if (h.getBrand().equalsIgnoreCase(brand)) return 1 + countHP(node.left,brand) + countHP(node.right,brand); return countHP(node.left, brand) + countHP(node.right, brand);

public double calTotalPrice(String brand) { return calculateTotal (root, brand); } private double calculateTotal(TreeNode node, String brand) if (node == null) return 0; else Handphone h = (Handphone) node.data; if (h.getBrand().equalsIgnoreCase(brand)) return h.getPrice() + calculateTotal(node.left, brand) + calculateTotal(node.right, brand); return calculateTotal(node.left, brand) + calculateTotal(node.right, brand);

Public static void main(String[] args) { Scanner s = new Scanner(System.in); BSTHandphone Bst = new BSTHandphone(); for (int i=0; i<5;i++) int pNum = s.nextInt(); String brand = s.next(); double price = s.nextDouble(); String owner = s.next(); int year = s.nextInt(); Handphone h = new Handphone (pNum, brand, price, owner, year); Bst.insertData(h); } System.out.println(Bst.countHandphoneBrand(brand); System.out.println(Bst.calTotalPrice(brand); }}