CS II: Data Structures

Discussion worksheet: Week 8

Trees

1) Vocabulary Answer the following question based on the above tree (Fig 8.3)
a. Which node is the root?

Sol. /user/rt/courses/

b. What are the internal nodes?

Sol. /user/rt/courses/, cs016/, cs252/, homeworks/, programs/, projects/, papers/, demos/

c. What are the leaf nodes?

Sol. grades, hw1, hw2, hw3, pr1, pr3, pr3, buylow, sellhigh, market, grades

d. How many descendants does node cs016/ have?

Sol. 9

e. How many ancestors does node cs016/ have?

Sol. 1

f. What are the siblings of node homeworks/?

Sol. grades/, programs/

g. Which nodes are in the subtree rooted at node projects/?

 Sol. papers/, demos/

h. What is the depth of node papers/?

Sol. 2

i. What is the height of the tree?

Sol. 4

2) Finish the method sumOfLeaves, which calculates the sum of the leaf nodes' data fields. It
should not include the internal nodes in the sum. Use recursion.
/* Class containing left and right child of current
node and key value*/
class Node {

int data;
Node left, right;

public Node(int item) {

data = item;
left = right = null;
}
}

static int sumOfLeaves(Node root) {

if(root != null) {
if(root.left != null || root.right != null) {
return sumOfLeaves(root.left)
+ sumOfLeaves(root.right);
}
else {
return root.data;
}
}
else {
return 0;
}
}
3) In what order are positions visited during a (see Fig 8.6)
a. preorder traversal of the tree
b. postorder traversal of the tree
c. inorder traversal of the tree

Sol

Preorder (VLR): -/*+313+-952+*3-746

Postorder (LRV): 31+3*95-2+/374-*6+-

Inorder (LVR): 3+1*3/9-5+2-3*7-4+6

 4) In this problem, you will write a method for the BinaryTree class for performing an inorder
traversal of a binary tree in linear time.
// Example of Stack Push() and Pop()
public class StackDemo {
public static void main(String args[]) {
// creating stack
Stack st = new Stack();

// populating stack
st.push("Java");
st.push("Source");
st.push("code");

// removing top object

System.out.println("Removed object is: "+st.pop());

// elements after remove

System.out.println("Elements after remove: "+st);
}
}

/*

To remind you how Stack works, here is the output of the above program:

Removed object is: code

Elements after remove: [Java, Source]

*/

/* importing the necessary class */

import java.util.Stack;

/* Class containing left and right child of current

node and key value*/
class Node {

int data;
Node left, right;

public Node(int item) {

data = item;
left = right = null;
}
}

class BinaryTree {

Node root;
// non-recursive method for inorder traversal

void inorder() {
if (root == null) {
return;
}

// use stack to keep track of the Nodes you still need to visit.
// Keep in mind that the Stack starts empty
Stack<Node> stack = new Stack<Node>();
Node node = root;
//Your code here
while (node != null) {
stack.push(node);
node = node.left;
}
// traverse the tree
while (stack.size() > 0) {
// visit the top node
node = stack.pop();
System.out.print(node.data + " ");
if (node.right != null) {
node = node.right;
// the next node to be visited is the leftmost
while (node != null) {
stack.push(node);
node = node.left;
}
}
}
}

public static void main(String args[]) {

/* creating a binary tree and entering

the nodes */
BinaryTree tree = new BinaryTree();
tree.root = new Node(1);
tree.root.left = new Node(2);
tree.root.right = new Node(3);
tree.root.left.left = new Node(4);
tree.root.left.right = new Node(5);
tree.inorder();
}
}

Reflection: why did we need a data structure (like Stack) to write the non-recursive traversal but we
didn't need one for the recursive method sumOfLeaves?
 5) Two ordered trees T’ and T’’ are said to be "isomorphic" if one of the following holds:
a. Both T’ and T’’ are empty
b. Both T’ and T’’ consist of a single node
c. The roots of T’ and T’’ have the same number of k >= 1 of subtrees, and the ith such
subtree of T’ is isomorphic to the ith such subtree of T’’ for i = 1,…..,k
Design an algorithm that tests whether two given ordered trees are isomorphic. What is the
running time of your algorithm?

class BinaryTree
{
Node root1, root2;
/* Given a binary tree, print its nodes in reverse level order */
boolean isIsomorphic(Node n1, Node n2)
{
// Both roots are NULL, trees isomorphic by definition
if (n1 == null && n2 == null)
return true;
// Exactly one of the n1 and n2 is NULL, trees not isomorphic
if (n1 == null || n2 == null)
return false;
if (n1.data != n2.data)
return false;
// There are two possible cases for n1 and n2 to be isomorphic
// Case 1: The subtrees rooted at these nodes have NOT been
// "Flipped".
// Both of these subtrees have to be isomorphic.
// Case 2: The subtrees rooted at these nodes have been "Flipped"
return (isIsomorphic(n1.left, n2.left) &&
isIsomorphic(n1.right, n2.right))
|| (isIsomorphic(n1.left, n2.right) &&
isIsomorphic(n1.right, n2.left));
}

public static void main(String args[])

{
BinaryTree tree = new BinaryTree();
// Let us create trees shown in above diagram
tree.root1 = new Node(1);
tree.root1.left = new Node(2);
tree.root1.right = new Node(3);
tree.root1.left.left = new Node(4);
tree.root1.left.right = new Node(5);
tree.root1.right.left = new Node(6);
tree.root1.left.right.left = new Node(7);
tree.root1.left.right.right = new Node(8);

tree.root2 = new Node(1);

tree.root2.left = new Node(3);
tree.root2.right = new Node(2);
tree.root2.right.left = new Node(4);
tree.root2.right.right = new Node(5);
tree.root2.left.right = new Node(6);
tree.root2.right.right.left = new Node(8);
tree.root2.right.right.right = new Node(7);
 if (tree.isIsomorphic(tree.root1, tree.root2) == true)
System.out.println("Yes");
else
System.out.println("No");
}
}

Time complexity is O(m + n) where m and n are number of nodes in given trees

6) Give an O(n) time algorithm for printing the depths of all nodes of a tree T, where n is the
number of nodes of T.

Sol.

This can be done using a preorder traversal. When doing a "visit" in the traversal, simply store the
depth of the node’s parent incremented by 1. Now, every node will contain its depth.

Assuming depth is a variable associated with each node, we can compute node’s depth
computingDepths(v, d)
{
v.depth=d;
if ( v has no child )
return;
else
for each child v′ do
computingDepths(v′, d+1);
return;
}

To compute the depth of each node, simply call computeDepth(root, 0). This algorithm visits
each node only once and each visit takes constant time. Therefore, it’s running time is O(n)