D ESIGN & A NALYSIS OF A LGORITHM 05 – N - ARY T REE & B INARY T REE Informatics Department Parahyangan Catholic University

T REE R EPRESENTATION How do we store a tree in a computer software ? Store as a graph ? Hard to tell the parent-child relationship between its vertices Store in an array of parents ? (just like a DFS/BFS traversal tree) Only able to tell which vertex is the parent of a given vertex But we often need to know which is/are the child/children of a given vertex

T REE R EPRESENTATION [Recursive definition] A tree is either : An empty tree (has no vertex) A root with zero or more tree children [Recursive tree representation] A node (vertex) of a tree can have: A parent Zero or more node(s) as its children A Tree has either Null root, means it’s an empty tree (0 vertex) One root, mean it’s not an empty tree (>0 vertex)

E XAMPLE IN J AVA class Node{ Info info; Node parent; LinkedList children; } class Tree{ Node root; } class Node{ Info info; Node parent; LinkedList children; } class Tree{ Node root; }

N-A RY & B INARY T REE A tree is called n -ary tree if every node may have no more than n children. 2-ary tree is called binary tree Why is n important ? By limiting the number of children, the tree data structure is easier to implement Instead of a linked list of children, we can use a static array Instead of traversing through a linked list, we can directly access the k-th children by using the array’s index etc.

W HY ARE BINARY TREES SPECIAL ? Binary representation of computer data Every other trees can be represented as binary tree, which is more efficient if the average number of children is << n

E XAMPLE IN J AVA class Node{ Info info; Node parent; Node left, right; } class Tree{ Node root; } class Node{ Info info; Node parent; Node left, right; } class Tree{ Node root; } class Node{ Info info; Node parent; Node children[]; } class Tree{ Node root; } class Node{ Info info; Node parent; Node children[]; } class Tree{ Node root; } Binary treeN-ary tree

N- ARY TO B INARY T REE class Node{ Info info; Node parent; Node firstChild; Node nextSibling; } class Node{ Info info; Node parent; Node firstChild; Node nextSibling; } class Node{ Info info; Node parent; Node children[]; } class Node{ Info info; Node parent; Node children[]; } The root has a null sibling

T REE T RAVERSAL :: DFS Visit first child and all its descendant first, then visit the second sibling, etc DFS(x) visit(x) for each v child of x DFS(v) DFS(x) visit(x) for each v child of x DFS(v) DFS(x) if(x not NULL) visit(x) DFS(x.firstChild) DFS(x.nextSibling) DFS(x) if(x not NULL) visit(x) DFS(x.firstChild) DFS(x.nextSibling) Same as DFS on a binary tree

T REE T RAVERSAL :: DFS There are basically 3 variants of DFS Preorder visit the root, then the left subtree, then the right subtree Inorder visit the left subtree, then the root, then the right subtree Postorder visit the left subtree, then the right subtree, then the root Preorder, inorder, and postorder on n-ary tree Left subtree = first sibling subtree Right subtree = next sibling subtree DFS_PRE(x) if(x not NULL) visit(x) DFS(x.left) DFS(x.right) DFS_PRE(x) if(x not NULL) visit(x) DFS(x.left) DFS(x.right) Preorder DFS_IN(x) if(x not NULL) DFS(x.left) visit(x) DFS(x.right) DFS_IN(x) if(x not NULL) DFS(x.left) visit(x) DFS(x.right) Inorder DFS_POST(x) if(x not NULL) DFS(x.left) DFS(x.right) visit(x) DFS_POST(x) if(x not NULL) DFS(x.left) DFS(x.right) visit(x) Postorder

T REE T RAVERSAL :: BFS Similar to BFS traversal on a graph BFS() Q.enqueue(root) while not Q.isEmpty() x = Q.dequeue() visit(x) if(x.left not NULL) Q.enqueue(x.left) if(x.left not NULL) Q.enqueue(x.right) BFS() Q.enqueue(root) while not Q.isEmpty() x = Q.dequeue() visit(x) if(x.left not NULL) Q.enqueue(x.left) if(x.left not NULL) Q.enqueue(x.right)

S OME B ASIC M ETHODS Counting the number of nodes Computing depth COUNT(x) if (x == NULL) return 0 else return 1 + COUNT(x.left) + COUNT(x.right) COUNT(x) if (x == NULL) return 0 else return 1 + COUNT(x.left) + COUNT(x.right) DEPTH(x) if (x == NULL) return 0 else return 1 + MAX(DEPTH(x.left),DEPTH(x.right)) DEPTH(x) if (x == NULL) return 0 else return 1 + MAX(DEPTH(x.left),DEPTH(x.right))

S OME B ASIC M ETHODS Searching info in a tree rooted at x SEARCH(x, info) if (x == NULL) return NULL else if (x.info == info) return x else s = SEARCH(x.left, info) if(s not NULL) return s else return SEARCH(x.right, info) SEARCH(x, info) if (x == NULL) return NULL else if (x.info == info) return x else s = SEARCH(x.left, info) if(s not NULL) return s else return SEARCH(x.right, info)

B INARY S EARCH T REE BST is a binary tree which has the property that for any node x in the tree If y is a node in the left subtree of x then y.info < x.info If y is a node in the right subtree of x then y.info ≥ x.info Basic Methods Querying Searching Finding minimum / maximum Finding successor / predecessor Insertion & Deletion Sorting

S EARCHING Similar to Binary Search on an array SEARCH(x, info) if (x == NULL) return NULL else if (x.info == info) return x else if(info < x.info) return SEARCH(x.left, info) else return SEARCH(x.right, info) SEARCH(x, info) if (x == NULL) return NULL else if (x.info == info) return x else if(info < x.info) return SEARCH(x.left, info) else return SEARCH(x.right, info) x < x≥ x

M INIMUM / M AXIMUM The smallest element in a BST must be stored on the left most node, and similarly, the largest element is stored on the right most node MIN(x) if (x == NULL) return x else while(x.left not NULL) x = x.left return x MIN(x) if (x == NULL) return x else while(x.left not NULL) x = x.left return x MAX(x) if (x == NULL) return x else while(x.right not NULL) x = x.right return x MAX(x) if (x == NULL) return x else while(x.right not NULL) x = x.right return x

F INDING S UCCESSOR Successor = the smallest element among elements that is greater than x Case 1 : x has a right subtree Successor of x is the minimum of x ’s right subtree x

F INDING S UCCESSOR Case 2 : x doesn’t have a right subtree x z x < z x z (y<x) < z y x ynyn y1y1 z (y 1 <…<y n <x) < z

F INDING S UCCESSOR Case 3 : x doesn’t have a right subtree, and x is the right most element of the tree X doesn’t have a successor x SUCCESSOR(x) if (x.right not NULL) return MIN(x.right) else y = x.parent while(y not NULL AND x == y.right) x = y y = y.parent return y SUCCESSOR(x) if (x.right not NULL) return MIN(x.right) else y = x.parent while(y not NULL AND x == y.right) x = y y = y.parent return y Finding predecessor is very similar

BST I NSERTION TREE_INSERT(T, info) x = Node(info) if (T is an empty tree) T.root = x else INSERT(T.root, x) INSERT(curr, x) if(x.info < curr.info) if (curr.left == NULL) x.parent = curr curr.left = x else INSERT(curr.left, x) else if(curr.right == NULL) x.parent = curr curr.right = x else INSERT(curr.right, x) TREE_INSERT(T, info) x = Node(info) if (T is an empty tree) T.root = x else INSERT(T.root, x) INSERT(curr, x) if(x.info < curr.info) if (curr.left == NULL) x.parent = curr curr.left = x else INSERT(curr.left, x) else if(curr.right == NULL) x.parent = curr curr.right = x else INSERT(curr.right, x)

BST D ELETION It has three basic cases If the node to be deleted has no children, then just remove it If the node to be deleted has one child, then replace the node with its only child If the node to be deleted has two children, then replace with its successor Pseudocode is left as an exercise

S ORTING Given a list of data L = {a 1, a 2, …, a n } Successively insert the data into BST To view the sorted list just use DFS (inorder)

T IME C OMPLEXITY For a tree with n nodes Traversal visits every node, so it takes O(n) time Insertion can insert on the bottom most location of the tree, so it is proportional to the tree’s depth/height. Suppose the tree’s height is h, then Insertion takes O(h) time Searching, finding Maximum / Minimum, finding Successor / Predecessor are also O(h) Deletion might call successor, so it also O(h)

S ORTING Given a list of data L = {a 1, a 2, …, a n } Successively insert the data into BST To view the sorted list just use DFS (inorder) What is the complexty of Sorting ? Inserting n elements is O(n.h) Traversal takes O(n) So sorting takes O(n.h + n) = O(n.h) Inserting n elements is O(n.h) Traversal takes O(n) So sorting takes O(n.h + n) = O(n.h)

T REE ’ S H EIGHT / D EPTH The tree’s height determine the efficiency of BST’s operations Best case: h = lg(n) Worst case: h = n

B ALANCED T REE It is clear that a more balanced tree gives a better performance than the unbalanced one There are various attempts to build a balanced tree data structure, such as: Red-Black tree Self Balancing BST B-Tree Treap etc.