import java.util.LinkedList; public class IntTree { private Node root; private static class Node { public int key; public Node left, right; public Node(int key) { this.key = key; } } public void printInOrder() { printInOrder(root); } private void printInOrder(Node n) { if (n == null) return; printInOrder(n.left); System.out.println(n.key); printInOrder(n.right); } // Recall the definitions of height and depth. // in the BST with level order traversal "41 21 61 11 31", // node 41 has depth 0, height 2 // node 21 has depth 1, height 1 // node 61 has depth 1, height 0 // node 11 has depth 2, height 0 // node 31 has depth 2, height 0 // height of the whole tree is the height of the root /* * Returns true if for every node in the tree has the same number of nodes to * its left as to its right. For example, the BST with level order traversal 50 * 25 100 12 37 150 127 is NOT perfectly balanced. Although most of the nodes * (including the root) have the same number of nodes to the left as to the * right, the nodes with 100 and 150 do not and so the tree is not perfeclty * balanced. * * HINT: In the helper function, change the return type to int and return -1 if * the tree is not perfectly balanced otherwise return the size of the tree. If * a recursive call returns the size of the subtree, this will help you when you * need to determine if the tree at the current node is balanced. */ public boolean isPerfectlyBalanced() { // TODO throw new RuntimeException("Not implemented"); } • You are not allowed to use any kind of loop in your solutions. • You may not modify the Node class in any way • You may not modify the function headers of any of the functions already present in the file. • You may not add any fields to the IntTree class.
import java.util.LinkedList;
public class IntTree {
private Node root;
private static class Node {
public int key;
public Node left, right;
public Node(int key) {
this.key = key;
}
}
public void printInOrder() {
printInOrder(root);
}
private void printInOrder(Node n) {
if (n == null)
return;
printInOrder(n.left);
System.out.println(n.key);
printInOrder(n.right);
}
// Recall the definitions of height and depth.
// in the BST with level order traversal "41 21 61 11 31",
// node 41 has depth 0, height 2
// node 21 has depth 1, height 1
// node 61 has depth 1, height 0
// node 11 has depth 2, height 0
// node 31 has depth 2, height 0
// height of the whole tree is the height of the root
/*
* Returns true if for every node in the tree has the same number of nodes to
* its left as to its right. For example, the BST with level order traversal 50
* 25 100 12 37 150 127 is NOT perfectly balanced. Although most of the nodes
* (including the root) have the same number of nodes to the left as to the
* right, the nodes with 100 and 150 do not and so the tree is not perfeclty
* balanced.
*
* HINT: In the helper function, change the return type to int and return -1 if
* the tree is not perfectly balanced otherwise return the size of the tree. If
* a recursive call returns the size of the subtree, this will help you when you
* need to determine if the tree at the current node is balanced.
*/
public boolean isPerfectlyBalanced() {
// TODO
throw new RuntimeException("Not implemented");
}
• You are not allowed to use any kind of loop in your solutions.
• You may not modify the Node class in any way
• You may not modify the function headers of any of the functions already present in the file.
• You may not add any fields to the IntTree class.
Step by step
Solved in 4 steps with 3 images