Binary Tree Traversal

Traversal of Binary Tree The process of visiting each node in a tree Why the traversal necessary? Checking whether insertions/deletions work well. Searching a specific node. How to visit all nodes once? A B D E C F G H I J K

Traversal of Binary Tree Traversal methods Inorder traversal: LCR Visiting a left subtree, a root node, and a right subtree Preorder traversal: CLR Visiting the root node node before subtrees Postorder traversal: LRC Visiting subtrees before visiting the root node Level order traversal C L R

Inorder Traversal (LCR) Algorithm: LCR Step 1: Visiting a left subtree Step 2: Visiting the root node Step 3: Visiting a right subtree 6 2 A C L R 9 4 B C 2 5 7 11 D E F G 1 H I 3 8 J K 10 1 3

Inorder Traversal (LCR) Root A B C D E F G H I J K Left subtree Right subtree B D E H I C F G J K A

Inorder Traversal (LCR) B D E H I D B E A H I A Right subtree H D I B E A Left subtree C F G J K F G C K J F J C K G Left subtree Right subtree

Inorder Traversal (LCR) Algorithm void Inorder(BTreeNode* root) { if (root != NULL) Inorder(root->left_child); printf("%d ", root->item); Inorder(root->right_child); } 6 4 9 2 5 7 11 3 1 A B D E C F G H I J K 10 8 H D I B E A F J C K G

Preorder Traversal (CLR) Algorithm: CLR Step 1: Visiting the root node Step 2: Visiting a left subtree Step 3: Visiting a right subtree 1 2 7 3 6 8 10 5 4 A B D E C F G H I J K 11 9 1 C L R 2 3

Preorder Traversal (CLR) Root A B C D E F G H I J K Left subtree Right subtree B D E H I C F G J K A

Preorder Traversal (CLR) H I B D E H I A B E A Right subtree A B D H I E Left subtree C F G J K F J G K C C F J G K Left subtree Right subtree

Preorder Traversal (CLR) Algorithm: CLR void Preorder(BTreeNode* root) { if (root != NULL) printf("%d ", root->item); Preorder(root->left_child); Preorder(root->right_child); } 1 2 7 3 6 8 10 5 4 A B D E C F G H I J K 11 9 A B D H I E C F J G K

Postorder Traversal (LRC) Algorithm: LRC Step 1: Visiting a left subtree Step 2: Visiting a right subtree Step 3: Visiting the root node 11 5 10 3 4 7 9 2 1 A B D E C F G H I J K 8 6 3 C L R 1 2

Postorder Traversal (LRC) Root A B C D E F G H I J K Left subtree Right subtree B D E H I C F G J K A

Postorder Traversal (LRC) H I B D E H I E B Right subtree H I D E B Left subtree C F G J K F J G K C A A J F K G C A Left subtree Right subtree

Postorder Traversal (LRC) Algorithm: LRC void Postorder(BTreeNode* root) { if (root != NULL) Postorder(root->left_child); Postorder(root->right_child); printf("%d ", root->item); } 11 5 10 3 4 7 9 2 1 A B D E C F G H I J K 8 6 H I D E B J F K G C A

Inorder Postorder Preorder 11 5 10 3 4 7 9 2 1 A B D E C F G H I J K 8 6 4 9 2 5 7 11 3 1 A B D E C F G H I J K 10 8 11 5 10 3 4 7 9 2 1 A B D E C F G H I J K 8 6 Postorder Preorder 1 2 7 3 6 8 10 5 4 A B D E C F G H I J K 11 9

Level Order Traversal Algorithm For each level, visit nodes from the left to right direction. 1 Level 0 A 3 2 Level 1 B C 4 5 6 7 Level 2 D E F G 8 H I 9 10 J K 11 Level 3 A B C D E F G H I J K

Level Order Traversal Algorithm Traverse a tree by using a queue (FIFO) When dequeuing a node, enqueue its children from the left to the right direction. 1 2 3 4 5 6 7 9 8 A B D E C F G H I J K 11 10 EnQueue A A EnQueue B, C B C EnQueue D, E D E EnQueue F, G F G EnQueue H, I H I EnQueue - EnQueue J J EnQueue K K

Level Order Traversal void Levelorder(BTreeNode* root) { Queue queue; if (root == NULL) return; InitQueue(&queue); EnQueue(&queue, root); while (!IsEmpty(&queue)) root = Peek(&queue); DeQueue(&queue); printf("%d ", root->item); if (root->left_child != NULL) EnQueue(&queue, root->left_child); if (root->right_child != NULL) EnQueue(&queue, root->right_child); }

Calculating Directory Size How to accumulate directory size? Each file has different size, and each directory has 10K. 50K 150K 200K 30K 10K + 230K 10K + 200K 10K + 450K

Calculating Directory Size // Make use of postorder traversal. int CalDirectorySize(BTreeNode *root) { int left_size, right_size; if (root == NULL) return 0; else { left_size = CalDirectorySize(root->left_child); right_size = CalDirectorySize(root->right_child); return (root->item + left_size + right_size); } 10 50 150 200 30

Binary Expression Tree Infix notation: X + Y Operators are written in-between their operands. Need extra information to make the order of evaluation of the operators clear. Example: (7 + 4) * 2 – 1 The expression tree is easier to understand than infix notation. - * 1 + 2 7 4 (7 + 4) * 2 - 1

Binary Expression Tree Definition Representing an expression as a tree. Non-leaf node: operator, leaf node: operand + * c a b - + * a b c d + a b a+b a*b+c a+b-c*d Infix Prefix +ab +*abc -+ab*cd Postfix ab+ ab*c+ ab+cd*-

Calculating Expression Tree Calculate 7 + 4 and update the node. - - * 1 11 2 * 1 + 2 7 4 Calculating 7 + 4

Calculating Expression Tree Calculate 11 * 2 and update the node. Calculate 22 - 1 and update the node. - - 22 1 * 1 11 2 Calculating 11 * 2 - 22 1 21 Calculating 22 - 1

Calculating Expression Tree int CalculateExpTree(BTreeNode * root) { int op1, op2; if (root == NULL) return 0; if (root->left_child == NULL && root->right_child == NULL) return root->item; op1 = CalculateExpTree(root->left_child); op2 = CalculateExpTree(root->right_child); switch (root->item) case '+': return op1 + op2; case '-': return op1 - op2; case '*': return op1 * op2; case '/': return op1 / op2; } return 0;

Building Expression Tree Overall procedure Infix notation  postfix notation Use a stack (See Lecture Note 3). Postfix notation  expression tree Build a tree incrementally using a stack. Infix notation Postfix notation Expression tree (7 + 4) * 2 - 1 7 4 + 2 * 1 - - * 1 + 2 7 4

Building Expression Tree Push nodes from operands until finding a operator. Pop two nodes and push an expression tree. 7 4 + 2 * 1 - 4 7 7 4 + 2 * 1 - + T = T 7 4

Building Expression Tree Push nodes from operands until finding a operator. Pop two nodes and push an expression tree. 7 4 + 2 * 1 - 2 + T = T 7 4 T’ = * + 2 7 4 7 4 + 2 * 1 - T’

Building Expression Tree Push nodes from operands until finding a operator. Pop two nodes and push an expression tree. * 7 4 + 2 * 1 - 1 T’ = + 2 T’ 7 4 T’’ = - * 1 + 2 7 4 7 4 + 2 * 1 - T’’

Building Expression Tree BTreeNode * MakeExpTree(char* exp, int len) { Stack stack; BTreeNode * node, *right_node, *left_node; InitStack(&stack); for (int i = 0; i < len; i++) { if ('0' <= exp[i] && exp[i] <= '9') node = CreateNode(exp[i]); else { right_node = Peek(&stack), Pop(&stack); left_node = Peek(&stack), Pop(&stack); CreateRightSubtree(node, right_node); CreateLeftSubtree(node, left_node); } Push(&stack, node); return Peek(&stack);

Threaded Binary Tree Variation of binary tree Modify a binary tree to cheaply find its inorder successor. Have special threading links (dashed arrows). It can be fast traversal. A B C D E F G H I J K

Threaded Binary Tree Inorder traversal Traverse a tree until finding the leftmost node. Solid arrows mean left-side movements. Traverse a tree by a threaded link or a right-side child pointer. Dashed arrows mean right-side movements. 6 A 9 4 B C 5 2 7 11 D E F G H I J K 1 3 8 10

Node in Threaded Binary Tree Node representation in threaded binary tree If no right child node exists, the right_child pointer of the node refers to its inorder successor. This node indicates a threaded node. typedef int BData; typedef struct _bTreeNode { BData item; struct _bTreeNode * left_child; struct _bTreeNode * right_child; bool isTheaded; } BTreeNode; item left_child right_child

Inorder in Threaded Binary Tree BTreeNode* leftMost(BTreeNode* node) { if (node == NULL) return NULL; while (node->left_child != NULL) node = node->left_child; // Go to the leftmost node. return node; } void inorder(BTreeNode* node) BTreeNode* cur = leftmost(node); while (cur != NULL) { printf("%d ", cur->item); // If the node is a thread node, go to its inorder successor. if (cur->isTheaded) cur = cur->right_child; else // Go to the leftmost child in a right subtree. cur = leftmost(cur->right_child);