Question

In the second part we'll begin with a recursive data structure that represents a tower of blocks. We represent such a Tower by its top block which for convenience we'll just take to be a char representing its colour, i.e something like 'B', G 'R' or Y' together with another Tower representing the rest of the blocks. The basic constructors and some utility functions are supplied. Your job will be to work out how to compute the height of a tower and the number of blocks in a tower of a given colour.

/**
* A recursive representation of a tower of blocks.
*
*
*/
public class Tower{

    /** The top block. */
    private char top;
  
    /** The rest of the tower. */
    private Tower rest;

    /**
     * Creates a new empty Tower.
     */
    public Tower() {
        this.top = ' ';
        this.rest = null;
    }
  
    /**
     * External classes can only create empty towers and manipulate
     * them using public methods, because this constructor is
     * private.
     * @param top the top block in this tower
     * @param rest the rest of the tower
     */
    private Tower(char top, Tower rest) {
        this.top = top;
        this.rest = rest;
    }

    /**
     * Returns true if this tower is empty, otherwise false. Empty
     * towers are represented with the top block being a space
     * character.
     * @return whether the tower is empty or not.
     */
    public boolean isEmpty() {
        return top == ' ';
    }
      
    /**
     * Creates a new tower by adding the given block to the top of
     * this tower.
     * @param block a block to add to the top of this tower.
     * @return a new tower created by adding a block to the top of
     * this tower.
     */
    public Tower add(char block) {
        return new Tower(block, this);
    }

}

Answer 1

/**
* A recursive representation of a tower of blocks.
*/
public class Tower {

   /** The top block. */
   private char top;

   /** The rest of the tower. */
   private Tower rest;

   /**
   * Creates a new empty Tower.
   */
   public Tower() {
       this.top = ' ';
       this.rest = null;
   }

   /**
   * External classes can only create empty towers and manipulate them using
   * public methods, because this constructor is private.
   *
   * @param top
   *            the top block in this tower
   * @param rest
   *            the rest of the tower
   */
   private Tower(char top, Tower rest) {
       this.top = top;
       this.rest = rest;
   }

   /**
   * Returns true if this tower is empty, otherwise false. Empty towers are
   * represented with the top block being a space character.
   *
   * @return whether the tower is empty or not.
   */
   public boolean isEmpty() {
       return top == ' ';
   }

   /**
   * Creates a new tower by adding the given block to the top of this tower.
   *
   * @param block
   *            a block to add to the top of this tower.
   * @return a new tower created by adding a block to the top of this tower.
   */
   public Tower add(char block) {
       return new Tower(block, this);
   }
  
   /**
   * Calculates the height of the tower recursively
   */
   private int height(Tower tower) {
       if (tower.rest == null)
           return 0;
       else {
           int height = 1;
           return (height + height(tower.rest));
       }
   }

   /**
   * Returns the height of the tower i.e. the number of blocks in the tower
   */
   public int height() {
       return height(this);
   }
  
   /**
   * Counts the number of 'c' blocks in the tower recursively
   */
   private int count(char c, Tower tower) {
       if (tower.rest == null)
           return 0;
       else {
           int count = (tower.top == c) ? 1 : 0;
           return (count + count(c, tower.rest));
       }
   }

   /**
   * Returns the number of blocks of 'c' (case sensitive) in the tower
   */
   public int count(char c) {
       return count(c, this);
   }

   @Override
   public String toString() {
       StringBuffer sb = new StringBuffer();

       if (!isEmpty()) {
           sb.append("\n" + top);
           Tower currBlock = rest;

           while (currBlock.rest != null) {
               sb.append("\n" + currBlock.top);
               currBlock = currBlock.rest;
           }
       } else
           sb.append("Tower is empty");

       return sb.toString();
   }
}

public class TowerTest {

   public static void main(String[] args) {

       // Create a new Tower
       Tower tower = new Tower();

       // Test if tower is empty
       System.out.println("Is Tower empty: " + tower.isEmpty());

       // Display the height of the tower
       System.out.println("Height of the tower: " + tower.height());

       // Display tower
       System.out.println("Tower: " + tower);

       // Add a block to the tower
       tower = tower.add('B');
       tower = tower.add('G');
       tower = tower.add('R');
       tower = tower.add('Y');

       System.out.println("\nAdding \'B\', \'G\', \'R\' and \'Y\' blocks to the tower");

       // Test if tower is empty
       System.out.println("Is Tower empty: " + tower.isEmpty());

       // Display the height of the tower
       System.out.println("Height of the tower: " + tower.height());

       // Display tower
       System.out.println("Tower: " + tower);

       // Display # of blocks of B
       System.out.println("Number of blocks of \'B\': " + tower.count('B'));

       // Display # of blocks of P
       System.out.println("Number of blocks of \'P\': " + tower.count('P'));
   }
}

SAMPLE OUTPUT:

Is Tower empty: true Height of the tower: 0 Tower: Tower is empty Adding 'B', 'G', 'R' and 'Y' blocks to the tower Is Tower empty: false Height of the tower 4 Tower R. Number of blocks of 'B 1 Number of blocks of 'P': O