Question

In need of JAVA CODE FOR THIS 

OBJECTIVE:

Modify the BST class I gave you as follows:
In the case in which the deleted node has two children, write the code in 
two ways. 

a) always replace the deleted node with the largest node on the left.
b) count how many deletions have been done, and for even deletions
replace the deleted node with the largest node on the left, for odd
deletions, replace the deleted node with the smallest node on the right.


Now do an experiment in which you add 100 random Doubles to the tree, then
repeatedly delete and add values many times. (Keep an array of the numbers currently in the tree and randomly choose an element of the array to delete.)

As you do each random deletion and insertion, note the depth of the tree, and
create a graph (using Excel?) that shows how the tree's depth changes.

Do this epxperiment for each of the deletion strategies a) and b).  How do
the graphs differ?

To generate the random numbers needed,

import java.util.Random;
then in your code,

Random ran = new Random();
ran.nextDouble(); gives a double between 0.0 and 1.0
ran.nextInt(n) gives a random integer between 0 and n-1 inclusive

BST CLASS:

public class BST<T extends Comparable<T>> 
{
  private Node<T> root;

  public BST()
  {
    this.root = null;
  }

  public void insert(T datum) throws BSTException
  {
    this.root = insert(this.root, datum);
  }

  private Node<T> insert(Node<T> r, T datum) throws BSTException
  {
    if( r == null)
    {
      return new Node<T>(datum);
    }
    else
    {
      int sign = r.getData().compareTo(datum);
      if(sign == 0)
      {
        throw new BSTException("Duplicate Entry " + datum);
      }
      else if(sign > 0)
      {
        r.setLeft(insert(r.getLeft(), datum));
      }
      else
      {
        r.setRight(insert(r.getRight(), datum));
      }
      return r;
    }
  }

  public T lookup(T target)
  {
    Node<T> where = root;
    T retval = null;

    while (where != null && retval == null)
    {
      int sign = where.getData().compareTo(target);
      if (sign == 0)
        retval = where.getData();
      else if(sign > 0)
        where = where.getLeft();
      else
        where = where.getRight();
    }
    return retval;
  }
 
  public void delete(T target)
  {
    root = delete(root, target);
    return;
  }

  private Node<T> delete(Node<T> root, T target)
  {
    //Tree is empty
    if (root == null)
      return root;
    // if not empty tree, search recursively for target
    int sign = target.compareTo(root.getData());
    if (sign < 0) //go left
      root.setLeft(delete(root.getLeft(), target));
    else if (sign > 0) //go right
      root.setRight(delete(root.getRight(), target));
    else // sign == 0 so we found it 
    {
      //case 1 and 2: 0 or 1 child
      if (root.getLeft() == null)
        return root.getRight();
      else if (root.getRight() == null)
        return root.getLeft();

      //if we get here, there are 2 children.
      //replace our data with minimum data 
      //in right subtree
      root.setData(minOnRight(root.getRight()));
      //or with maximum data in left subtree
      //root.setData(maxOnLeft(root.getLeft());
      
      //finally, delete the node whose data we
      //copied 
      root.setRight(delete(root.getRight(), root.getData()));
    }
    return root;
  }
      
  private T minOnRight(Node<T> r)
  {
    while(r.getLeft() != null)
      r = r.getLeft();
    return r.getData();
  }

  public int getDepth()
  {
    return getDepth(root);
  }

  public int getDepth(Node<T> r)
  {
    int retval = -1;
    if (r == null)
      return retval;
    else 
    {
      retval = Math.max(getDepth(r.getLeft()), getDepth(r.getRight()) ) + 1;
    }
    return retval;
  }

  public String toString()
  {
    String retval = "";
    return toString(root, retval);
  }

  public String toString(Node<T> r, String retval)
  {
    if (r == null)
    {
      return retval + "null" + "\n";
    }
    else
    {
      retval += r.getData() + "\n";
      retval = toString(r.getLeft(), retval);
      retval = toString(r.getRight(), retval);
    }
    return retval;
  }

  public static void main(String args[]) throws BSTException
  {
    BST<String> sbst = new BST<String>();
    sbst.insert("horse");
    sbst.insert("cow");
    sbst.insert("manticore");
    sbst.insert("jaguar");
    sbst.insert("zebra");
    sbst.insert("aardvark");
    sbst.insert("duck");
    System.out.println(sbst);
    System.out.println();
    sbst.delete("horse");
    System.out.println(sbst);
  }
}

Answer 1

Solution:
...............................................................................................................................................................

package bst;

import javafx.scene.Node;
import java.util.Random;
import java.util.Arrays;

public class BST<T extends Comparable<T>>
{
private Node<T> root;

public BST()
{
    this.root = null;
}
  
public boolean whetherEmpty() {
    
      if ( root == null)
            return true;
      else
            return false;
      // technically the same effect as the following short and sweet line
      // return root == null;
    
} // end function whether empty or not

public void findDepth () {
      // recursive function to find the depth of the tree
  
      // generating 100 random doubles and adding them to the tree to hold them
      double [] tempTree = new double[100];
      Random rn = new Random();     // rn = random number
      double r;
      for (int i = 0; i<100; i++)   {
          //int r = rn.nextInt(); // r = random value
          r = rn.nextDouble();
          System.out.println("Adding the random double value" + (r) + " to the tree");
      } // end for
      //
    
    
} // end function findDepth

public void insert(T datum) throws BSTException
{
    this.root = recInsert(this.root, datum);
    // insert recursively into the BS Tree
}

private Node<T> recInsert(Node<T> r, T datum)
throws BSTException
{
    if( r == null)
    {
      return new Node<T>(datum);
    } // end of then condition
    else
    {
      int sign = r.getData().compareTo(datum);
      if(sign == 0)
      {
        throw new BSTException("Duplicate Entry " +
datum);
      }
      else if(sign > 0)
      { // deal with the left sub tree
        r.setLeft(recInsert(r.getLeft(), datum));
      }
      else
      { // focus on the right sub tree
        r.setRight(recInsert(r.getRight(), datum));
      }
      return r;
    }
}

public T lookup(T target)
{
    Node<T> where = root;
    T retval = null;

    while (where != null && retval == null)
    {
      int sign = where.getData().compareTo(target);
      if (sign == 0)
        retval = where.getData();
      else if(sign > 0)
        where = where.getLeft();
      else
        where = where.getRight();
    }
    return retval;
}

public T delete(T target)
{
    //to be written
    
      // the delete method or function
    
      if ( (whetherEmpty())) {
          System.out.println("Sorry, the tree seems to be empty or null - please add some nodes and then try this option again, thanks......");
          else if (seek(target) == false )   // seek - you (thou) shall find the node to be deleted !!!!!
              System.out.println("Oops, you do not have to over kill - the node " + (target) + " you are trying to delete is not there first of all \n please do not beat a dead snake - try to delete some other existing node.....");
          else { // finalyy can delete successfully
                  root = delete (root, target);
                  System.out.println(target + " had been got rid off from the tree");
                  } // end else
      } // end if
    
      // (a) Replace the deleted node with the largest node on the left
    
    
    
    
      // [b] count the number of deletions
    
      // for each even deletion, replace the deleted nde with the largest node on the left
    
    
      // for each odd deletion, replace teh deleted node with the smallest node on the right
    
    
      // hence it is the largest left and smallest right for even and odd respectively
    
    
    
    
    return target;
}

public String toString()
{
    String retval = "";
    return recToString(root, retval);
}

    /**
     *
     * @param r
     * @param retval
     * @return
     */
    public String recToString(Node<T> r, String retval)
{
    if (r == null)
    {
      return retval + "null" + "\n";
    }
    else
    {
      retval += r.getData() + "\n";
      retval = recToString(r.getLeft(), retval);
      retval = recToString(r.getRight(), retval);
    }
    return retval;
}

public static void main(String args[]) throws
BSTException
{
    BST<Integer> sbst = new BST<Integer>();

 sbst.insert("horse");
    sbst.insert("cow");
    sbst.insert("manticore");
    sbst.insert("jaguar");
    sbst.insert("zebra");
    sbst.insert("aardvark");
    sbst.insert("duck");
    System.out.println(sbst);
    System.out.println();
    sbst.delete("horse");
    System.out.println(sbst);

}

    private static class BSTException extends Exception {

        public BSTException() {
        }

        private BSTException(String string) {
            throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
        }
    }
}