Question

Preliminaries

Download the template class and the driver file.

Objective

Learn how to traverse a binary search tree in order.

Description

For the template class BinarySearchTree, fill in the following methods:

insert - Inserts values greater than the parent to the right, and values lesser than the parent to the left.parameters

elem - The new element to be inserted into the tree.

printInOrder - Prints the values stored in the tree in ascending order.

Hint: Use a recursive method to visit the left subtree, then print out the value, then visit the right subtree.

getDepth - Finds the depth of a node within the tree. Depth is defined as the number of edges from the root to the nodeparameters

elem - The element to find the depth of

return The depth of the element within the tree. If the value is not found, -1 is returned.

Template Class:

public class BinarySearchTree<E extends Comparable<E>> {
  private class Node<E> {
    private E data;
    private Node<E> left;
    private Node<E> right;

    public Node(E data) {
      this.data = data;
      this.left = null;
      this.right = null;
    }
  }

  private Node<E> root;

  public BinarySearchTree() {
    root = null;
  }

  /**
   * Inserts an element into the tree.
   * @param elem The new element to be inserted into the tree.
   */
  public void insert(E elem) {
    // Finish this method
  }

  /**
   * Prints the values stored in the tree in ascending order.
   */
  public void printInorder() {
    // Finish this method
  }

  /**
   * Finds the depth of a node within the tree. Depth is defined
   * as the number of edges from the root to the node.
   * @param elem The element to find the depth of
   * @return The depth of the element within the tree. If the value
   *         is not found, -1 is returned.
   */
  public int getDepth(E elem) {
    // Finish this method
  }

  /* Do not modify below this line! */
  /* -------------------------------------------------------------- */
  /**
   * Checks whether the nth bit within an integer is set.
   * @param number The number to check
   * @param index The index of the bit to find
   * @return True if the nth bit is set. For example, (5, 1) is true
   *         since 5 = b101, and the ones place is set. Similarly, (5, 2)
   *         is false.
   */
  private static boolean nthBitSet(int number, int index) {
    int constant = 1 << (index - 1);
    return (number & constant) != 0;
  }

  /**
   * Prints an ascii representation of the tree.
   * @param root The current node to print
   * @param depth The level of the tree in which the current node lies.
   *              Levels are counted with the root starting at 0.
   * @param isLeft Whether the current node is a left child.
   * @param parBits A bitstring (integer) representing the parents
   *                in the path above this node. Used to 'fill in
   *                the gaps' in the drawing.
   * @param buffered Whether this was called to specifically include
   *                 additional whitespace on the left
   */
  public void printAscii(Node<E> root, int depth, boolean isLeft, int parBits,
                         boolean buffered) {
    if (root == null) {
      return;
    }
    for (int i = 0; i < (depth - 1) * 3; i++) {
      if (i % 3 == 1 && nthBitSet(parBits, depth - (i / 3))) {
        System.out.print("|");
      } else {
        System.out.print(" ");
      }
    }
    if (isLeft && depth != 0 && !buffered) {
      System.out.print(" `- ");
    } else if (depth != 0 && !buffered) {
      System.out.print(" |- ");
    }
    if (buffered) {
      for (int i = 0; i < depth * 3; i++) {
        System.out.print(" ");
      }
    }
    System.out.println(root.data);

    boolean hasRight = root.right != null;
    boolean hasLeft = root.left != null;
    int newParBits = parBits << 1;
    if (hasLeft) {
      newParBits++;
    }

    printAscii(root.right, depth + 1, !hasLeft, newParBits, false);
    printAscii(root.left, depth + 1, true, --newParBits, false);
  }

  /**
   * Prints an ascii representation of the tree.
   */
  public void printAscii() {
    printAscii(root, 0, false, 0, false);
  }
}

Driver file:

import java.util.ArrayList;
import java.util.Random;

public class TreeTester {
  public static final int RANDOM_TEST_SIZE = 15;

  /**
   * Run tests.
   */
  public static void main(String[] args) {
    System.out.println("Integer test");
    testInt();
    System.out.println("----------");
    System.out.println("Randomized Char test");
    randomCharTest();
  }

  /**
   * Test BinarySearchTree on a predetermined selection of integers.
   */
  public static void testInt() {
    BinarySearchTree<Integer> tree = new BinarySearchTree<Integer>();
    int[] valArr = {4,8,10,2,1,7,3,5,9,6};
    for (int i : valArr) {
      tree.insert(i);
    }
    System.out.println("Tree:");
    tree.printAscii();
    System.out.println("Testing insertion by in-order traversal");
    tree.printInorder();
    System.out.print("Depth of 6: ");
    System.out.println(tree.getDepth(6));
    System.out.print("Getting depth of 14: ");
    System.out.println(tree.getDepth(14));
  }

  /**
   * Test BinarySearchTree on a random selection of characters.
   */
  public static void randomCharTest() {
    BinarySearchTree<Character> tree = new BinarySearchTree<Character>();
    // Create the list of chars
    ArrayList<Character> alphabet = new ArrayList<Character>();
    for (int i = 97; i < 123; i++) {
      alphabet.add((char) i);
    }
    Random rand = new Random();
    ArrayList<Character> inTree = new ArrayList<Character>();
    for (int i = 0; i < RANDOM_TEST_SIZE; i++) {
      int removeIndex = rand.nextInt(alphabet.size());
      Character charToAdd = alphabet.remove(removeIndex);
      tree.insert(charToAdd);
      inTree.add(charToAdd);
    }
    tree.printAscii();
    System.out.println("Testing insertion by in-order traversal");
    tree.printInorder();

    // Test the depth of two elements in the tree
    System.out.println("Finding depth of random elements within the tree:");
    for (int i = 0; i < 2; i++) {
      int randIndex = rand.nextInt(inTree.size());
      System.out.print("Depth of " + inTree.get(randIndex) + ": ");
      System.out.println(tree.getDepth(inTree.get(randIndex)));
    }
    ArrayList<Character> outOfTree = alphabet;
    System.out.println("Finding depth of random elements outside the tree:");
    int randIndex = rand.nextInt(outOfTree.size());
    System.out.print("Depth of " + outOfTree.get(randIndex) + ": ");
    System.out.println(tree.getDepth(outOfTree.get(randIndex)));
  }
}

Example Dialog

      Integer test
      Tree:
      4
       |- 8
       |  |- 10
       |  |  `- 9
       |  `- 7
       |     `- 5
       |        `- 6
       `- 2
          |- 3
          `- 1
      Testing insertion by in-order traversal
      1 2 3 4 5 6 7 8 9 10
      Depth of 6: 4
      Getting depth of 14: -1
      ----------
      Randomized Char test
      i
       |- t
       |  |- w
       |  |  `- y
       |  |     `- z
       |  `- r
       |     |- s
       |     `- k
       |        `- n
       |           `- p
       `- c
          |- e
          |  `- h
          |     `- f
          `- b
      Testing insertion by in-order traversal
      b c e f h i k n p r s t w y z
      Finding depth of random elements within the tree:
      Depth of e: 2
      Depth of z: 4
      Finding depth of random elements outside the tree:
      Depth of x: -1

Answer 1

Provided java code as per your requirements.

• Bold the modified(add) code in given program. Revert back if you have any clarification.

Java Code:

public class BinarySearchTree<E extends Comparable<E>> {
private class Node<E> {
  private E data;
  private Node<E> left;
  private Node<E> right;

  public Node(E data) {
   this.data = data;
   this.left = null;
   this.right = null;
  }
}

private Node<E> root;

public BinarySearchTree() {
  root = null;
}

/**
* Inserts an element into the tree.
*
* @param elem
*            The new element to be inserted into the tree.
*/
public void insert(E elem) {
  Node<E> newNode = new Node<E>(elem);

  if (root == null)
   root = newNode;
  else {
   Node<E> current = root;
   Node<E> parent;

   while (true) {
    parent = current;
    if (((Comparable<E>) elem).compareTo(current.data) < 0) {
     current = current.left;
     if (current == null) {
      parent.left = newNode;
      return;
     }
    } else {
     current = current.right;
     if (current == null) {
      parent.right = newNode;
      return;
     }
    }
   }
  }
}

/**
* Prints the values stored in the tree in ascending order.
*/
public void printInorder() {
  printInInorder(root);
}

private void printInInorder(Node<E> root) {
  if (root != null) {
   printInInorder(root.left);
   System.out.print(root.data + " ");
   printInInorder(root.right);
  }
}

/**
* Finds the depth of a node within the tree. Depth is defined as the number
* of edges from the root to the node.
*
* @param elem
*            The element to find the depth of
* @return The depth of the element within the tree. If the value is not
*         found, -1 is returned.
*/

public int getDepth(E elem) {

  Node<E> temp = get(elem);

  return getDepth(temp);
}

public Node<E> get(E elem) {
  if (root == null) {
   return null;
  }
  Node<E> runner = root;
  while (true) {
   if (((Comparable<E>) runner.data).compareTo(elem) > 0) {
    if (runner.left == null) {
     return null;
    }
    runner = runner.left;
   } else if (((Comparable<E>) runner.data).compareTo(elem) < 0) {
    if (runner.right == null) {
     return null;
    }
    runner = runner.right;
   } else {
    return runner;
   }
  }
}

public int getDepth(Node<E> node) {
  if (node == null)
   return 0;
  else {
   int lheight = getDepth(node.left);
   int rheight = getDepth(node.right);

   if (lheight > rheight)
    return (lheight + 1);
   else
    return (rheight + 1);
  }
}

/* Do not modify below this line! */
/* -------------------------------------------------------------- */
/**
* Checks whether the nth bit within an integer is set.
*
* @param number
*            The number to check
* @param index
*            The index of the bit to find
* @return True if the nth bit is set. For example, (5, 1) is true since 5 =
*         b101, and the ones place is set. Similarly, (5, 2) is false.
*/
private static boolean nthBitSet(int number, int index) {
  int constant = 1 << (index - 1);
  return (number & constant) != 0;
}

/**
* Prints an ascii representation of the tree.
*
* @param root
*            The current node to print
* @param depth
*            The level of the tree in which the current node lies. Levels
*            are counted with the root starting at 0.
* @param isLeft
*            Whether the current node is a left child.
* @param parBits
*            A bitstring (integer) representing the parents in the path
*            above this node. Used to 'fill in the gaps' in the drawing.
* @param buffered
*            Whether this was called to specifically include additional
*            whitespace on the left
*/
public void printAscii(Node<E> root, int depth, boolean isLeft,
   int parBits, boolean buffered) {
  if (root == null) {
   return;
  }
  for (int i = 0; i < (depth - 1) * 3; i++) {
   if (i % 3 == 1 && nthBitSet(parBits, depth - (i / 3))) {
    System.out.print("|");
   } else {
    System.out.print(" ");
   }
  }
  if (isLeft && depth != 0 && !buffered) {
   System.out.print(" `- ");
  } else if (depth != 0 && !buffered) {
   System.out.print(" |- ");
  }
  if (buffered) {
   for (int i = 0; i < depth * 3; i++) {
    System.out.print(" ");
   }
  }
  System.out.println(root.data);

  boolean hasRight = root.right != null;
  boolean hasLeft = root.left != null;
  int newParBits = parBits << 1;
  if (hasLeft) {
   newParBits++;
  }

  printAscii(root.right, depth + 1, !hasLeft, newParBits, false);
  printAscii(root.left, depth + 1, true, --newParBits, false);
}

/**
* Prints an ascii representation of the tree.
*/
public void printAscii() {
  printAscii(root, 0, false, 0, false);
}
}

import java.util.ArrayList;
import java.util.Random;

public class TreeTester {
public static final int RANDOM_TEST_SIZE = 15;

/**
* Run tests.
*/
public static void main(String[] args) {
  System.out.println("Integer test");
  testInt();
  System.out.println("----------");
  System.out.println("Randomized Char test");
  randomCharTest();
}

/**
* Test BinarySearchTree on a predetermined selection of integers.
*/
public static void testInt() {
  BinarySearchTree<Integer> tree = new BinarySearchTree<Integer>();
  int[] valArr = { 4, 8, 10, 2, 1, 7, 3, 5, 9, 6 };
  for (int i : valArr) {
   tree.insert(i);
  }
  System.out.println("Tree:");
  tree.printAscii();
  System.out.println("Testing insertion by in-order traversal");
  tree.printInorder();
  System.out.print("Depth of 6: ");
  System.out.println(tree.getDepth(6));
  System.out.print("Getting depth of 14: ");
  System.out.println(tree.getDepth(14));
}

/**
* Test BinarySearchTree on a random selection of characters.
*/
public static void randomCharTest() {
  BinarySearchTree<Character> tree = new BinarySearchTree<Character>();
  // Create the list of chars
  ArrayList<Character> alphabet = new ArrayList<Character>();
  for (int i = 97; i < 123; i++) {
   alphabet.add((char) i);
  }
  Random rand = new Random();
  ArrayList<Character> inTree = new ArrayList<Character>();
  for (int i = 0; i < RANDOM_TEST_SIZE; i++) {
   int removeIndex = rand.nextInt(alphabet.size());
   Character charToAdd = alphabet.remove(removeIndex);
   tree.insert(charToAdd);
   inTree.add(charToAdd);
  }
  tree.printAscii();
  System.out.println("Testing insertion by in-order traversal");
  tree.printInorder();

  // Test the depth of two elements in the tree
  System.out.println("Finding depth of random elements within the tree:");
  for (int i = 0; i < 2; i++) {
   int randIndex = rand.nextInt(inTree.size());
   System.out.print("Depth of " + inTree.get(randIndex) + ": ");
   System.out.println(tree.getDepth(inTree.get(randIndex)));
  }
  ArrayList<Character> outOfTree = alphabet;
  System.out
    .println("Finding depth of random elements outside the tree:");
  int randIndex = rand.nextInt(outOfTree.size());
  System.out.print("Depth of " + outOfTree.get(randIndex) + ": ");
  System.out.println(tree.getDepth(outOfTree.get(randIndex)));
}
}

Output: