Question

Start with the tree.java program (Listing 8.1) and modify it to create a binary
tree from a string of letters (like A, B, and so on) entered by the user. Each
letter will be displayed in its own node. Construct the tree so that all the nodes
that contain letters are leaves. Parent nodes can contain some non-letter
symbol like +. Make sure that every parent node has exactly two children.
Don’t worry if the tree is unbalanced. Note that this will not be a search tree;
there’s no quick way to find a given node. You may end up with something
like this:
+
+ E
+ D - -
+ C - - - - - -
A B - - - - - - - - - - - - - -

Expand the program in Programming Project 8.1 to create a balanced tree. One
way to do this is to make sure that as many leaves as possible appear in the
bottom row. You can start by making a three-node tree out of each pair of onenode
trees, making a new + node for the root. This results in a forest of threenode
trees. Then combine each pair of three-node trees to make a forest of
seven-node trees. As the number of nodes per tree grows, the number of trees
shrinks, until finally there is only one tree left.

Here is the example tree.java program to use below.>>>>>>>

// tree.java
// demonstrates binary tree
// to run this program: C>java TreeApp
import java.io.*;
import java.util.*; // for Stack class
////////////////////////////////////////////////////////////////
class Node
{
public int iData; // data item (key)
public double dData; // data item
public Node leftChild; // this node's left child
public Node rightChild; // this node's right child

public void displayNode() // display ourself
{
System.out.print('{');
System.out.print(iData);
System.out.print(", ");
System.out.print(dData);
System.out.print("} ");
}
} // end class Node
////////////////////////////////////////////////////////////////
class Tree
{
private Node root; // first node of tree

// -------------------------------------------------------------
public Tree() // constructor
{ root = null; } // no nodes in tree yet
// -------------------------------------------------------------
public Node find(int key) // find node with given key
{ // (assumes non-empty tree)
Node current = root; // start at root
while(current.iData != key) // while no match,
{
if(key < current.iData) // go left?
current = current.leftChild;
else // or go right?
current = current.rightChild;
if(current == null) // if no child,
return null; // didn't find it
}
return current; // found it
} // end find()
// -------------------------------------------------------------
public void insert(int id, double dd)
{
Node newNode = new Node(); // make new node
newNode.iData = id; // insert data
newNode.dData = dd;
if(root==null) // no node in root
root = newNode;
else // root occupied
{
Node current = root; // start at root
Node parent;
while(true) // (exits internally)
{
parent = current;
if(id < current.iData) // go left?
{
current = current.leftChild;
if(current == null) // if end of the line,
{ // insert on left
parent.leftChild = newNode;
return;
}
} // end if go left
else // or go right?
{
current = current.rightChild;
if(current == null) // if end of the line
{ // insert on right
parent.rightChild = newNode;
return;
}
} // end else go right
} // end while
} // end else not root
} // end insert()
// -------------------------------------------------------------
public boolean delete(int key) // delete node with given key
{ // (assumes non-empty list)
Node current = root;
Node parent = root;
boolean isLeftChild = true;

while(current.iData != key) // search for node
{
parent = current;
if(key < current.iData) // go left?
{
isLeftChild = true;
current = current.leftChild;
}
else // or go right?
{
isLeftChild = false;
current = current.rightChild;
}
if(current == null) // end of the line,
return false; // didn't find it
} // end while
// found node to delete

// if no children, simply delete it
if(current.leftChild==null &&
current.rightChild==null)
{
if(current == root) // if root,
root = null; // tree is empty
else if(isLeftChild)
parent.leftChild = null; // disconnect
else // from parent
parent.rightChild = null;
}

// if no right child, replace with left subtree
else if(current.rightChild==null)
if(current == root)
root = current.leftChild;
else if(isLeftChild)
parent.leftChild = current.leftChild;
else
parent.rightChild = current.leftChild;

// if no left child, replace with right subtree
else if(current.leftChild==null)
if(current == root)
root = current.rightChild;
else if(isLeftChild)
parent.leftChild = current.rightChild;
else
parent.rightChild = current.rightChild;

else // two children, so replace with inorder successor
{
// get successor of node to delete (current)
Node successor = getSuccessor(current);

// connect parent of current to successor instead
if(current == root)
root = successor;
else if(isLeftChild)
parent.leftChild = successor;
else
parent.rightChild = successor;

// connect successor to current's left child
successor.leftChild = current.leftChild;
} // end else two children
// (successor cannot have a left child)
return true; // success
} // end delete()
// -------------------------------------------------------------
// returns node with next-highest value after delNode
// goes to right child, then right child's left descendents
private Node getSuccessor(Node delNode)
{
Node successorParent = delNode;
Node successor = delNode;
Node current = delNode.rightChild; // go to right child
while(current != null) // until no more
{ // left children,
successorParent = successor;
successor = current;
current = current.leftChild; // go to left child
}
// if successor not
if(successor != delNode.rightChild) // right child,
{ // make connections
successorParent.leftChild = successor.rightChild;
successor.rightChild = delNode.rightChild;
}
return successor;
}
// -------------------------------------------------------------
public void traverse(int traverseType)
{
switch(traverseType)
{
case 1: System.out.print("\nPreorder traversal: ");
preOrder(root);
break;
case 2: System.out.print("\nInorder traversal: ");
inOrder(root);
break;
case 3: System.out.print("\nPostorder traversal: ");
postOrder(root);
break;
}
System.out.println();
}
// -------------------------------------------------------------
private void preOrder(Node localRoot)
{
if(localRoot != null)
{
System.out.print(localRoot.iData + " ");
preOrder(localRoot.leftChild);
preOrder(localRoot.rightChild);
}
}
// -------------------------------------------------------------
private void inOrder(Node localRoot)
{
if(localRoot != null)
{
inOrder(localRoot.leftChild);
System.out.print(localRoot.iData + " ");
inOrder(localRoot.rightChild);
}
}
// -------------------------------------------------------------
private void postOrder(Node localRoot)
{
if(localRoot != null)
{
postOrder(localRoot.leftChild);
postOrder(localRoot.rightChild);
System.out.print(localRoot.iData + " ");
}
}
// -------------------------------------------------------------
public void displayTree()
{
Stack globalStack = new Stack();
globalStack.push(root);
int nBlanks = 32;
boolean isRowEmpty = false;
System.out.println(
"......................................................");
while(isRowEmpty==false)
{
Stack localStack = new Stack();
isRowEmpty = true;

for(int j=0; j<nBlanks; j++)
System.out.print(' ');

while(globalStack.isEmpty()==false)
{
Node temp = (Node)globalStack.pop();
if(temp != null)
{
System.out.print(temp.iData);
localStack.push(temp.leftChild);
localStack.push(temp.rightChild);

if(temp.leftChild != null ||
temp.rightChild != null)
isRowEmpty = false;
}
else
{
System.out.print("--");
localStack.push(null);
localStack.push(null);
}
for(int j=0; j<nBlanks*2-2; j++)
System.out.print(' ');
} // end while globalStack not empty
System.out.println();
nBlanks /= 2;
while(localStack.isEmpty()==false)
globalStack.push( localStack.pop() );
} // end while isRowEmpty is false
System.out.println(
"......................................................");
} // end displayTree()
// -------------------------------------------------------------
} // end class Tree
////////////////////////////////////////////////////////////////
class TreeApp
{
public static void main(String[] args) throws IOException
{
int value;
Tree theTree = new Tree();

theTree.insert(50, 1.5);
theTree.insert(25, 1.2);
theTree.insert(75, 1.7);
theTree.insert(12, 1.5);
theTree.insert(37, 1.2);
theTree.insert(43, 1.7);
theTree.insert(30, 1.5);
theTree.insert(33, 1.2);
theTree.insert(87, 1.7);
theTree.insert(93, 1.5);
theTree.insert(97, 1.5);

while(true)
{
System.out.print("Enter first letter of show, ");
System.out.print("insert, find, delete, or traverse: ");
int choice = getChar();
switch(choice)
{
case 's':
theTree.displayTree();
break;
case 'i':
System.out.print("Enter value to insert: ");
value = getInt();
theTree.insert(value, value + 0.9);
break;
case 'f':
System.out.print("Enter value to find: ");
value = getInt();
Node found = theTree.find(value);
if(found != null)
{
System.out.print("Found: ");
found.displayNode();
System.out.print("\n");
}
else
System.out.print("Could not find ");
System.out.print(value + '\n');
break;
case 'd':
System.out.print("Enter value to delete: ");
value = getInt();
boolean didDelete = theTree.delete(value);
if(didDelete)
System.out.print("Deleted " + value + '\n');
else
System.out.print("Could not delete ");
System.out.print(value + '\n');
break;
case 't':
System.out.print("Enter type 1, 2 or 3: ");
value = getInt();
theTree.traverse(value);
break;
default:
System.out.print("Invalid entry\n");
} // end switch
} // end while
} // end main()
// -------------------------------------------------------------
public static String getString() throws IOException
{
InputStreamReader isr = new InputStreamReader(System.in);
BufferedReader br = new BufferedReader(isr);
String s = br.readLine();
return s;
}
// -------------------------------------------------------------
public static char getChar() throws IOException
{
String s = getString();
return s.charAt(0);
}
//-------------------------------------------------------------
public static int getInt() throws IOException
{
String s = getString();
return Integer.parseInt(s);
}
// -------------------------------------------------------------
} // end class TreeApp
////////////////////////////////////////////////////////////////

Answer 1

First step is to convert the data to type String instead of int. Please find the code below with comments. Changed parts are bold. Note that the methods createUnbalanced and createBalanced address the first and the second questions respectively. Also find the code explanation and sample output below the code.

.....................................................................CODE STARTS HERE.............................................................................

// tree.java
// demonstrates binary tree
// to run this program: C>java TreeApp
import java.io.*;
import java.util.*;       // for Stack class
////////////////////////////////////////////////////////////////
class Node
{
public int iData;       // data item (key)
public String dData;       // data item
public Node leftChild;   // this node's left child
public Node rightChild;   // this node's right child

public void displayNode ()   // display ourself
{
    System.out.print ('{');
    System.out.print (iData);
    System.out.print (", ");
    System.out.print (dData);
    System.out.print ("} ");
}
}               // end class Node
////////////////////////////////////////////////////////////////
class Tree
{
private Node root;       // first node of tree

// -------------------------------------------------------------
public Tree ()       // constructor
{
    root = null;
}               // no nodes in tree yet
// -------------------------------------------------------------
public Node find (int key)   // find node with given key
{               // (assumes non-empty tree)
    Node current = root;   // start at root
    while (current.iData != key)   // while no match,
      {
   if (key < current.iData)   // go left?
      current = current.leftChild;
   else           // or go right?
      current = current.rightChild;
   if (current == null)   // if no child,
      return null;       // didn't find it
      }
    return current;       // found it
}               // end find()
// -------------------------------------------------------------
public void insert (int id, String dd)
{
    Node newNode = new Node ();   // make new node
    newNode.iData = id;       // insert data
    newNode.dData = dd;
    if (root == null)       // no node in root
      root = newNode;
    else           // root occupied
      {
   Node current = root;   // start at root
   Node parent;
   while (true)       // (exits internally)
      {
        parent = current;
        if (id < current.iData)   // go left?
          {
       current = current.leftChild;
       if (current == null)   // if end of the line,
          {       // insert on left
            parent.leftChild = newNode;
            return;
          }
          }           // end if go left
        else       // or go right?
          {
       current = current.rightChild;
       if (current == null)   // if end of the line
          {       // insert on right
            parent.rightChild = newNode;
            return;
          }
          }           // end else go right
      }           // end while
      }               // end else not root
}               // end insert()
// -------------------------------------------------------------
public Node createNode(int id, String dd) {
    Node newNode = new Node();
    newNode.iData = id;
    newNode.dData = dd;
    return newNode;
}

public void createUnbalanced(String str)
{
    int i=0; // String iterator
    root = createNode(0, "+"); // We don't care about the key, as we're not maintaining the BST structure
    Node current = root; // Set current at root
    while(i < str.length()) { // Iterate for all characters
        if (i == str.length() - 1) { // Last character
            current.dData = Character.toString(str.charAt(i)); // If last character, don't need to create child, just relabel it
        } else {
            Node l = createNode(0, "+"); // Set left node as +
            Node r = createNode(0, Character.toString(str.charAt(i))); // Set right node as the current character
            current.leftChild = l;
            current.rightChild = r;
            current = current.leftChild; // Set current as the left node (+) for the next iteration
        }
        i++;
    }
}

public Node createBalancedUtil(String str) // Recursive
{
    Node curRoot = createNode(0, "+"); // Create new root node for the current substr
    if (str.length() == 0) {
        return curRoot;
    }
  
    if (str.length() == 1) {
        curRoot.dData = str; // If just one character, set the node string to that character and return the node
    } else {
        int mid = str.length()/2; // Split the string into two almost equal parts
        Node l = createBalancedUtil(str.substring(0, mid)); // Create the subtree for the left part
        Node r = createBalancedUtil(str.substring(mid)); // Create the subtree for the right part
        // Make the two subtrees the left and right subtree of a new node (+)
        curRoot.leftChild = l;
        curRoot.rightChild = r;
    }
    return curRoot; // Return the root of this subtree
}

public void createBalanced(String str)
{
    root = createBalancedUtil(str); // Set the main root to the returned root
}

// -------------------------------------------------------------
public boolean delete (int key)   // delete node with given key
{               // (assumes non-empty list)
    Node current = root;
    Node parent = root;
    boolean isLeftChild = true;

    while (current.iData != key)   // search for node
      {
   parent = current;
   if (key < current.iData)   // go left?
      {
        isLeftChild = true;
        current = current.leftChild;
      }
   else           // or go right?
      {
        isLeftChild = false;
        current = current.rightChild;
      }
   if (current == null)   // end of the line,
      return false;       // didn't find it
      }               // end while
// found node to delete

// if no children, simply delete it
    if (current.leftChild == null && current.rightChild == null)
      {
   if (current == root)   // if root,
      root = null;       // tree is empty
   else if (isLeftChild)
      parent.leftChild = null;   // disconnect
   else           // from parent
      parent.rightChild = null;
      }

// if no right child, replace with left subtree
    else if (current.rightChild == null)
      if (current == root)
   root = current.leftChild;
      else if (isLeftChild)
   parent.leftChild = current.leftChild;
      else
   parent.rightChild = current.leftChild;

// if no left child, replace with right subtree
    else if (current.leftChild == null)
      if (current == root)
   root = current.rightChild;
      else if (isLeftChild)
   parent.leftChild = current.rightChild;
      else
   parent.rightChild = current.rightChild;

    else           // two children, so replace with inorder successor
      {
// get successor of node to delete (current)
   Node successor = getSuccessor (current);

// connect parent of current to successor instead
   if (current == root)
      root = successor;
   else if (isLeftChild)
      parent.leftChild = successor;
   else
      parent.rightChild = successor;

// connect successor to current's left child
   successor.leftChild = current.leftChild;
      }               // end else two children
// (successor cannot have a left child)
    return true;       // success
}               // end delete()
// -------------------------------------------------------------
// returns node with next-highest value after delNode
// goes to right child, then right child's left descendents
private Node getSuccessor (Node delNode)
{
    Node successorParent = delNode;
    Node successor = delNode;
    Node current = delNode.rightChild;   // go to right child
    while (current != null)   // until no more
      {               // left children,
   successorParent = successor;
   successor = current;
   current = current.leftChild;   // go to left child
      }
// if successor not
    if (successor != delNode.rightChild)   // right child,
      {               // make connections
   successorParent.leftChild = successor.rightChild;
   successor.rightChild = delNode.rightChild;
      }
    return successor;
}
// -------------------------------------------------------------
public void traverse (int traverseType)
{
    switch (traverseType)
      {
      case 1:
   System.out.print ("\nPreorder traversal: ");
   preOrder (root);
   break;
      case 2:
   System.out.print ("\nInorder traversal: ");
   inOrder (root);
   break;
      case 3:
   System.out.print ("\nPostorder traversal: ");
   postOrder (root);
   break;
      }
    System.out.println ();
}
// -------------------------------------------------------------
private void preOrder (Node localRoot)
{
    if (localRoot != null)
      {
   System.out.print (localRoot.iData + " ");
   preOrder (localRoot.leftChild);
   preOrder (localRoot.rightChild);
      }
}
// -------------------------------------------------------------
private void inOrder (Node localRoot)
{
    if (localRoot != null)
      {
   inOrder (localRoot.leftChild);
   System.out.print (localRoot.iData + " ");
   inOrder (localRoot.rightChild);
      }
}
// -------------------------------------------------------------
private void postOrder (Node localRoot)
{
    if (localRoot != null)
      {
   postOrder (localRoot.leftChild);
   postOrder (localRoot.rightChild);
   System.out.print (localRoot.iData + " ");
      }
}
// -------------------------------------------------------------
public void displayTree ()
{
    Stack globalStack = new Stack ();
    globalStack.push (root);
    int nBlanks = 32;
    boolean isRowEmpty = false;
    System.
      out.println ("......................................................");
    while (isRowEmpty == false)
      {
   Stack localStack = new Stack ();
   isRowEmpty = true;

   for (int j = 0; j < nBlanks; j++)
      System.out.print (' ');

   while (globalStack.isEmpty () == false)
      {
        Node temp = (Node) globalStack.pop ();
        if (temp != null)
          {
       System.out.print (temp.dData);
       localStack.push (temp.leftChild);
       localStack.push (temp.rightChild);

       if (temp.leftChild != null || temp.rightChild != null)
          isRowEmpty = false;
          }
        else
          {
       System.out.print ("--");
       localStack.push (null);
       localStack.push (null);
          }
        for (int j = 0; j < nBlanks * 2 - 2; j++)
          System.out.print (' ');
      }           // end while globalStack not empty
   System.out.println ();
   nBlanks /= 2;
   while (localStack.isEmpty () == false)
      globalStack.push (localStack.pop ());
      }               // end while isRowEmpty is false
    System.
      out.println ("......................................................");
}               // end displayTree()
// -------------------------------------------------------------
}               // end class Tree

////////////////////////////////////////////////////////////////
class TreeApp
{
public static void main (String[]args) throws IOException
{
    int value;
    Tree theTree = new Tree ();

      System.out.print ("Enter the string of letters for unbalanced: ");
      String str = getString();
      theTree.createUnbalanced(str);
      theTree.displayTree();
    
      System.out.print ("Enter the string of letters for balanced: ");
      str = getString();
      theTree.createBalanced(str);
      theTree.displayTree();
    
    

}               // end main()
// -------------------------------------------------------------
public static String getString () throws IOException
{
    InputStreamReader isr = new InputStreamReader (System.in);
    BufferedReader br = new BufferedReader (isr);
    String s = br.readLine ();
      return s;
}
// -------------------------------------------------------------
public static char getChar () throws IOException
{
    String s = getString ();
      return s.charAt (0);
}
//-------------------------------------------------------------
public static int getInt () throws IOException
{
    String s = getString ();
      return Integer.parseInt (s);
}
// -------------------------------------------------------------
}               // end class TreeApp
////////////////////////////////////////////////////////////////

.......................................................................CODE ENDS HERE............................................................................

SAMPLE OUTPUT: part in bold is the user input

Enter the string of letters for unbalanced: ABCDE
......................................................
                                +                                                            
                +                              A                            
        +              B              --              --            
    +      C      --      --      --      --      --      --    
E D -- -- -- -- -- -- -- -- -- -- -- -- -- --
......................................................

Enter the string of letters for balanced: ABCDE
......................................................
                                +                                                            
                +                              +                            
        A              B              C              +            
    --      --      --      --      --      --      D      E    
......................................................

As you can see, the unbalanced version is quite tilted to the left, while the balanced version looks, well, quite balanced.

Let us see why that happened.

CODE EXPLANATION:

Unbalanced version:

• Set the root as +
• At each iteration, take the leftmost +, and add two children to it as follows
• Left child will be a + ; right child will be the current character.
• This ensures no character has children (ie. they are leaf nodes)

Balanced version:

• This is a divide and conquer approach.
• For the current string, split it into two substrings of almost equal lengths.
• Create the tree for each of the two substrings.
• Combine the two trees adding a + node as root.
• This ensures that the tree is balanced. Difference in heights of both the trees will be at most 1.

..........................................................................................................................................................................................

Feel free to ask any doubts, I'll be happy to help!