Question

Writing traversal methods

You will create two files in the csc403 package: one called A3SimplerBST.java and the other TestA3.java. Details on these programs appears below.

Copy the file SimplerBST.java from the week 1 examples package and rename the file and class A3SimplerBST. Add two public methods:

• one named twoChildrenCount that takes no parameters and that, when called, traverses every node of the tree to count how many nodes have two children.
• one named sameValueCount that takes a paremeter of generic type V, and that, when called, traverses every node of the tree to count the number of nodes whose value (not its key) is equal to the value passed as a parameter. To check equality you must use the equals method and not the == operator.

As with the get, put, and delete methods, you will need each of the public methods described above to call a corresponding private recursive method.

Next, write a program called TestA3 that:

• Reads the words in the file data/tale.txt into an array using the StdIn.readAllStrings() method.
• Fills a A3SimplerBST symbol table object with counts of words in that array. It should also keep a count of the number of unique words by adding 1 to a counter whenever a word is first added to the symbol table.
• Prints the unique word count, which also is the number of nodes in the BST.
• Calls the twoChildrenCount method for the A3SimplerBST symbol table and prints the value returned.
• Calls the sameValueCount method for the A3SimplerBST symbol table to count and print how many words occur once and then again how many words occur 5 times.

// Having issue with sameValueCount, dont exactly know if Im comparing correctly, give stack overflow issue

package csc;

/*
* This is a simplified version of the BST class
* from the algs32 package.
*
*/
import stdlib.*;
import algs13.Queue;
import csc.A3SimplerBST.Node;

public class A3SimplerBST, V> {
   private Node root; // root of BST

   public static class Node, V> {
       public K key; // sorted by key
       public V val; // associated data
       public Node left, right; // left and right subtrees

       public Node(K key, V val) {
           this.key = key;
           this.val = val;
       }
   }

   public A3SimplerBST() {
   }

   /*
   * *********************************************************************
   * Search BST for given key, and return associated value if found, return
   * null if not found
   ***********************************************************************/
   // does there exist a key-value pair with given key?
   public boolean contains(K key) {
       return get(key) != null;
   }

   // return value associated with the given key, or null if no such key exists
   public V get(K key) {
       return get(root, key);
   }

   private V get(Node x, K key) {
       if (x == null)
           return null;
       int cmp = key.compareTo(x.key);
       if (cmp < 0)
           return get(x.left, key);
       else if (cmp > 0)
           return get(x.right, key);
       else
           return x.val;
   }

   /*
   * *********************************************************************
   * Insert key-value pair into BST If key already exists, update with new
   * value
   ***********************************************************************/
   public void put(K key, V val) {
       if (val == null) {
           delete(key);
           return;
       }
       root = put(root, key, val);
   }

   private Node put(Node x, K key, V val) {
       if (x == null)
           return new Node<>(key, val);
       int cmp = key.compareTo(x.key);
       if (cmp < 0)
           x.left = put(x.left, key, val);
       else if (cmp > 0)
           x.right = put(x.right, key, val);
       else
           x.val = val;
       return x;
   }

   /*
   * *********************************************************************
   * Delete
   ***********************************************************************/

   public void delete(K key) {
       root = delete(root, key);
   }

   private Node delete(Node x, K key) {
       if (x == null)
           return null;
       int cmp = key.compareTo(x.key);
       if (cmp < 0)
           x.left = delete(x.left, key);
       else if (cmp > 0)
           x.right = delete(x.right, key);
       else {
           // x is the node to be deleted.
           // The value returned in each of these cases below
           // becomes the value of the child reference from
           // the parent of x. Returning a null makes that
           // reference a null and so cuts x off, causing its
           // automatic deletion.

           // Determine how many children x has.
           if (x.right == null && x.left == null) {
               // This is a leaf node.
               return null;
           } else if (x.right == null) {
               // One child, to the left.
               return x.left;
           } else if (x.left == null) {
               // One child, to the right.
               return x.right;
           } else {
               // Node x has two children.
               // Find the node in x's right subtree with
               // the minimum key.
               Node rightTreeMinNode = findMin(x.right);
               x.key = rightTreeMinNode.key;
               x.val = rightTreeMinNode.val;
               x.right = delete(x.right, rightTreeMinNode.key);
           }
       }
       return x;
   }

   private Node findMin(Node x) {
       if (x.left == null)
           return x;
       else
           return findMin(x.left);
   }

   public void printKeys() {
       printKeys(root);
   }

   private void printKeys(Node x) {
       if (x == null)
           return;
       printKeys(x.left);
       StdOut.println(x.key);
       printKeys(x.right);
   }

   public Iterable keys() {
       Queue q = new Queue<>();
       inOrder(root, q);
       return q;
   }

   private void inOrder(Node x, Queue q) {
       if (x == null)
           return;
       inOrder(x.left, q);
       q.enqueue(x.key);
       inOrder(x.right, q);
   }

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

   private int height(Node x) {
       if (x == null)
           return -1;
       return 1 + Math.max(height(x.left), height(x.right));
   }

   /*
   * *************************************************************************
   * ** Visualization
   *****************************************************************************/

   public void drawTree() {
       if (root != null) {
           StdDraw.setPenColor(StdDraw.BLACK);
           StdDraw.setCanvasSize(1200, 700);
           drawTree(root, .5, 1, .25, 0);
       }
   }

   private void drawTree(Node n, double x, double y, double range, int depth) {
       int CUTOFF = 10;
       StdDraw.text(x, y, n.key.toString());
       StdDraw.setPenRadius(.007);
       if (n.left != null && depth != CUTOFF) {
           StdDraw.line(x - range, y - .08, x - .01, y - .01);
           drawTree(n.left, x - range, y - .1, range * .5, depth + 1);
       }
       if (n.right != null && depth != CUTOFF) {
           StdDraw.line(x + range, y - .08, x + .01, y - .01);
           drawTree(n.right, x + range, y - .1, range * .5, depth + 1);
       }
   }

  

      
  

public long sameValueCount(String key) {

       return sameValueCount(root, key);
   }

   // one named sameValueCount that takes a parameter of generic type V

   private long sameValueCount(Node x, String key) {
       // when called, traverses every node of the tree to count the number of
       // nodes
       // whose value (not its key) is equal to the value passed as a parameter

       if (x == null) {

           return 0;
       }
      
       if (x.val.equals(key)) {

           return 1 + sameValueCount(x.left, key) + sameValueCount(x.right, key);

       }
       return sameValueCount(x.left, key) + sameValueCount(x.right, key);
   }

}

Answer 1

Because your tree is generic, the method should also be generic.. I ran this code on data/tale.txt file and it works fine.. Just see the screenshot below:

public long sameValueCount(V key) {
    return sameValueCount(root, key);
}

// one named sameValueCount that takes a parameter of generic type V
private long sameValueCount(Node<K, V> x, V key) {
    // when called, traverses every node of the tree to count the number of
    // nodes
    // whose value (not its key) is equal to the value passed as a parameter
    if (x == null) {
        return 0;
    }

    if (x.val.equals(key)) {
        return 1 + sameValueCount(x.left, key) + sameValueCount(x.right, key);
    }
    return sameValueCount(x.left, key) + sameValueCount(x.right, key);
}

I can say with full confidence that the method has been coded correctly. If you are still facing issue, then just look at how you are creating the tree. If some loops are getting created while making the tree, then that can be a issue..

i am putting my class also for your help:

package csc403;

/*
 * This is a simplified version of the BST class
 * from the algs32 package.  
 * 
 */
import stdlib.*;
import algs13.Queue;

public class A3SimplerBST<K extends Comparable<? super K>, V> {
    private Node<K, V> root; // root of BST

    private static class Node<K extends Comparable<? super K>, V> {
        public K key; // sorted by key
        public V val; // associated data
        public Node<K, V> left, right; // left and right subtrees

        public Node(K key, V val) {
            this.key = key;
            this.val = val;
        }
    }

    public A3SimplerBST() {
    }

    /*
     * ********************************************************************* Search
     * BST for given key, and return associated value if found, return null if not
     * found
     ***********************************************************************/
    // does there exist a key-value pair with given key?
    public boolean contains(K key) {
        return get(key) != null;
    }

    // return value associated with the given key, or null if no such key exists
    public V get(K key) {
        return get(root, key);
    }

    private V get(Node<K, V> x, K key) {
        if (x == null)
            return null;
        int cmp = key.compareTo(x.key);
        if (cmp < 0)
            return get(x.left, key);
        else if (cmp > 0)
            return get(x.right, key);
        else
            return x.val;
    }

    /*
     * ********************************************************************* Insert
     * key-value pair into BST If key already exists, update with new value
     ***********************************************************************/
    public void put(K key, V val) {
        if (val == null) {
            delete(key);
            return;
        }
        root = put(root, key, val);
    }

    private Node<K, V> put(Node<K, V> x, K key, V val) {
        if (x == null)
            return new Node<>(key, val);
        int cmp = key.compareTo(x.key);
        if (cmp < 0)
            x.left = put(x.left, key, val);
        else if (cmp > 0)
            x.right = put(x.right, key, val);
        else
            x.val = val;
        return x;
    }

    /*
     * ********************************************************************* Delete
     ***********************************************************************/
    public void delete(K key) {
        root = delete(root, key);
    }

    private Node<K, V> delete(Node<K, V> x, K key) {
        if (x == null)
            return null;
        int cmp = key.compareTo(x.key);
        if (cmp < 0)
            x.left = delete(x.left, key);
        else if (cmp > 0)
            x.right = delete(x.right, key);
        else {
            // x is the node to be deleted.
            // The value returned in each of these cases below
            // becomes the value of the child reference from
            // the parent of x. Returning a null makes that
            // reference a null and so cuts x off, causing its
            // automatic deletion.

            // Determine how many children x has.
            if (x.right == null && x.left == null) {
                // This is a leaf node.
                return null;
            } else if (x.right == null) {
                // One child, to the left.
                return x.left;
            } else if (x.left == null) {
                // One child, to the right.
                return x.right;
            } else {
                // Node x has two children.
                // Find the node in x's right subtree with
                // the minimum key.
                Node<K, V> rightTreeMinNode = findMin(x.right);
                x.key = rightTreeMinNode.key;
                x.val = rightTreeMinNode.val;
                x.right = delete(x.right, rightTreeMinNode.key);
            }
        }
        return x;
    }

    private Node<K, V> findMin(Node<K, V> x) {
        if (x.left == null)
            return x;
        else
            return findMin(x.left);
    }

    public void printKeys() {
        printKeys(root);
    }

    private void printKeys(Node<K, V> x) {
        if (x == null)
            return;
        printKeys(x.left);
        StdOut.println(x.key);
        printKeys(x.right);
    }

    public Iterable<K> keys() {
        Queue<K> q = new Queue<>();
        inOrder(root, q);
        return q;
    }

    private void inOrder(Node<K, V> x, Queue<K> q) {
        if (x == null)
            return;
        inOrder(x.left, q);
        q.enqueue(x.key);
        inOrder(x.right, q);
    }

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

    private int height(Node<K, V> x) {
        if (x == null)
            return -1;
        return 1 + Math.max(height(x.left), height(x.right));
    }

    /*
     * ***************************************************************************
     * Visualization
     *****************************************************************************/
    public void drawTree() {
        if (root != null) {
            StdDraw.setPenColor(StdDraw.BLACK);
            StdDraw.setCanvasSize(1200, 700);
            drawTree(root, .5, 1, .25, 0);
        }
    }

    private void drawTree(Node<K, V> n, double x, double y, double range, int depth) {
        int CUTOFF = 10;
        StdDraw.text(x, y, n.key.toString());
        StdDraw.setPenRadius(.007);
        if (n.left != null && depth != CUTOFF) {
            StdDraw.line(x - range, y - .08, x - .01, y - .01);
            drawTree(n.left, x - range, y - .1, range * .5, depth + 1);
        }
        if (n.right != null && depth != CUTOFF) {
            StdDraw.line(x + range, y - .08, x + .01, y - .01);
            drawTree(n.right, x + range, y - .1, range * .5, depth + 1);
        }
    }

    /*
     * ***************************************************************************
     * Below method finds the number of leaves in tree
     *****************************************************************************/
    public int leafCount() {
        return leafCount(root);
    }

    private int leafCount(Node<K, V> startNode) {
        // if node is null, leaf count is 0
        if (startNode == null) {
            return 0;
        }
        if (startNode.right == null && startNode.left == null) {
            // this node is a leaf node.
            return 1;
        }

        // else, node may have 1 or 2 child, so this node is not a leaf
        // Node can have child which will have leaves
        int leavesOnLeft = leafCount(startNode.left);
        int leavesOnRight = leafCount(startNode.right);

        // return the total count of leaves
        return leavesOnLeft + leavesOnRight;
    }

    public long sameValueCount(V key) {
        return sameValueCount(root, key);
    }

    // one named sameValueCount that takes a parameter of generic type V
    private long sameValueCount(Node<K, V> x, V key) {
        // when called, traverses every node of the tree to count the number of
        // nodes
        // whose value (not its key) is equal to the value passed as a parameter
        if (x == null) {
            return 0;
        }

        if (x.val.equals(key)) {
            return 1 + sameValueCount(x.left, key) + sameValueCount(x.right, key);
        }
        return sameValueCount(x.left, key) + sameValueCount(x.right, key);
    }
}

plz upvote.